yearn-treasury 0.0.15__cp311-cp311-win_amd64.whl → 0.1.3__cp311-cp311-win_amd64.whl

yearn_treasury/rules/ignore/swaps/vaults.py

@@ -0,0 +1,264 @@
+from typing import Final, cast
+
+from dao_treasury import TreasuryTx, TreasuryWallet
+from dao_treasury.db import Address
+from eth_typing import BlockNumber, ChecksumAddress
+from faster_async_lru import alru_cache
+from y import Contract, Network
+from y.prices.yearn import YearnInspiredVault
+
+from yearn_treasury.constants import CHAINID, TREASURY_WALLETS
+from yearn_treasury.rules.ignore.swaps import swaps
+from yearn_treasury.rules.constants import ZERO_ADDRESS
+from yearn_treasury.vaults import v1, v2
+
+
+vaults: Final = swaps("Vaults")
+
+TREASURY_AND_ZERO: Final = {*TREASURY_WALLETS, ZERO_ADDRESS}
+
+all_vaults: Final = tuple(v1.keys()) + tuple(v2.values())
+
+
+@vaults("Deposit")
+async def is_vault_deposit(tx: TreasuryTx) -> bool:
+    return (
+        await is_v1_or_v2_vault_deposit(tx)
+        or tx.hash
+        in {
+            # TODO these go thru zaps and do not get caught by the logic below. figure out how to capture these
+            Network.Mainnet: {  # type: ignore [call-overload]
+                "0x39616fdfc8851e10e17d955f55beea5c3dd4eed7c066a8ecbed8e50b496012ff",
+                "0x248e896eb732dfe40a0fa49131717bb7d2c1721743a2945ab9680787abcf9c50",
+                "0x2ce0240a08c8cc8d35b018995862711eb660a24d294b1aa674fbc467af4e621b",
+                # this is not thru a zap, its a lp-yCRVv2 deposit I probably dont need to write hueristics for
+                "0x93cf055d82b7e82b3877ab506629de6359fc5385ffb6b8c2fbfe0d61947fab59",
+            }
+        }.get(CHAINID, set())
+        or is_v3_vault_deposit(tx)
+    )
+
+
+async def is_v1_or_v2_vault_deposit(tx: TreasuryTx) -> bool:
+    """This code doesn't validate amounts but so far that's not been a problem."""
+    try:
+        if "Transfer" not in tx.events:
+            return False
+    except KeyError as e:
+        # This happens sometimes from a busted abi, shouldnt impact us
+        if str(e) == "'components'":
+            return False
+        raise
+
+    transfer_events = tx.events["Transfer"]
+
+    tx_token = tx.token_address
+
+    block = BlockNumber(tx.block)
+    sender: ChecksumAddress
+    receiver: ChecksumAddress
+    underlying_address: ChecksumAddress
+
+    # vault side
+    for vault in all_vaults:
+        if tx_token == vault.address:
+            for event in transfer_events:
+                if tx_token == event.address:
+                    event_pos = event.pos
+                    sender, receiver, value = event.values()
+                    if sender == ZERO_ADDRESS and TreasuryWallet.check_membership(receiver, block):
+                        tx_to_address = tx.to_address
+                        underlying_address = await _get_underlying(vault)
+                        for _event in transfer_events:
+                            _sender, _receiver, _value = _event.values()
+                            if (
+                                _event.address == underlying_address
+                                and tx_to_address == _sender
+                                and tx_token == _receiver
+                            ):
+                                # v1
+                                if _event.pos < event_pos:
+                                    return True
+                                # v2
+                                if event_pos < _event.pos:
+                                    return True
+
+    # token side
+    for vault in all_vaults:
+        if tx_token == await _get_underlying(vault):
+            for event in transfer_events:
+                if tx_token == event.address:
+                    vault_address = vault.address
+                    event_pos = event.pos
+                    sender, receiver, value = event.values()
+                    if TreasuryWallet.check_membership(sender, block) and receiver == vault_address:
+                        for _event in transfer_events:
+                            _sender, _receiver, _value = _event.values()
+                            if (
+                                _event.address == vault_address
+                                and _sender == ZERO_ADDRESS
+                                and TreasuryWallet.check_membership(_receiver, block)
+                            ):
+                                # v1?
+                                if event_pos < _event.pos:
+                                    return True
+                                # v2
+                                if _event.pos < event_pos:
+                                    return True
+    return False
+
+
+_v3_deposit_keys: Final = "sender", "owner", "assets", "shares"
+
+
+def is_v3_vault_deposit(tx: TreasuryTx) -> bool:
+    try:
+        if "Deposit" not in tx.events:
+            return False
+    except KeyError as e:
+        # This happens sometimes due to a busted abi, shouldnt impact us
+        if str(e) == "'components'":
+            return False
+        raise
+
+    if deposits := [
+        event for event in tx.events["Deposit"] if all(key in event for key in _v3_deposit_keys)
+    ]:
+        token = tx.token
+        to_address = tx.to_address
+        amount = tx.amount
+
+        # Vault side
+        if tx.from_address == ZERO_ADDRESS:
+            token_address = token.address.address
+            if deposits := [d for d in deposits if token_address == d.address]:
+                for deposit in deposits:
+                    if to_address != deposit["owner"]:
+                        print("wrong owner")
+                        continue
+                    # TODO: once postgres is in, remove the `round`
+                    # elif amount == (scaled := token.scale_value(deposit["shares"])):
+                    #     return True
+                    amount = round(amount, 8)
+                    scaled = round(token.scale_value(deposit["shares"]), 8)
+                    if amount == scaled:
+                        return True
+                    print(f"wrong amount:  tx={amount}  event={scaled}")
+                print("no matching vault-side deposit found")
+
+        # Token side
+        elif deposits := [d for d in deposits if to_address == d.address]:
+            from_address = cast(Address, tx.from_address).address
+            for deposit in deposits:
+                if from_address != deposit["sender"]:
+                    print("sender doesnt match")
+                    continue
+                # TODO: once postgres is in, remove the `round`
+                amount = round(amount, 8)
+                scaled = round(token.scale_value(deposit["assets"]), 8)
+                if amount == scaled:
+                    return True
+                print(f"wrong amount:  tx={amount}  event={scaled}")
+            print("no matching token-side deposit found")
+    return False
+
+
+@alru_cache(maxsize=None)
+async def _get_underlying(vault: Contract) -> ChecksumAddress:
+    underlying = await YearnInspiredVault(vault, asynchronous=True).underlying
+    return underlying.address  # type: ignore [return-value]
+
+
+@vaults("Withdrawal")
+async def is_vault_withdrawal(tx: TreasuryTx) -> bool:
+    to_address = cast(Address, tx.to_address).address
+    if to_address not in TREASURY_AND_ZERO:
+        return False
+
+    try:
+        if "Transfer" not in tx.events:
+            return False
+    except KeyError as e:
+        if str(e) == "'components'":
+            return False
+        raise
+
+    transfer_events = tx.events["Transfer"]
+
+    token = tx.token
+    token_address = cast(ChecksumAddress, token.address.address)
+    block = BlockNumber(tx.block)
+
+    underlying: ChecksumAddress
+
+    # vault side
+    if any(token_address == vault.address for vault in all_vaults):
+        for event in transfer_events:
+            if token_address == event.address:
+                sender, receiver, value = event.values()
+                if (
+                    to_address == ZERO_ADDRESS == receiver
+                    and TreasuryWallet.check_membership(sender, block)
+                    and tx.from_address == sender
+                ):
+                    underlying = await _get_underlying(token_address)
+                    for _event in transfer_events:
+                        _sender, _receiver, _value = _event.values()
+                        if (
+                            _event.address == underlying
+                            and tx.from_address == _receiver
+                            and event.pos < _event.pos
+                            and token_address == _sender
+                        ):
+                            return True
+    # token side
+    for vault in all_vaults:
+        if token_address == await _get_underlying(vault):
+            vault_address = vault.address
+            for event in transfer_events:
+                if token_address == event.address:
+                    sender, receiver, value = event.values()
+                    if tx.from_address == vault_address == sender and to_address == receiver:
+                        for _event in transfer_events:
+                            _sender, _receiver, _value = _event.values()
+                            if (
+                                _event.address == vault_address
+                                and _receiver == ZERO_ADDRESS
+                                and TreasuryWallet.check_membership(_sender, block)
+                                and to_address == _sender
+                                and _event.pos < event.pos
+                            ):
+                                return True
+    return False
+
+
+@vaults("DOLA Fed Withdrawal")
+def is_dolla_fed_withdrawal(tx: TreasuryTx) -> bool:
+    if tx.from_nickname == "Token: Curve DOLA Pool yVault - Unlisted" and TreasuryWallet.check_membership(tx.to_address.address, tx.block) and tx.symbol == "DOLA3POOL3CRV-f":  # type: ignore [union-attr, arg-type]
+        return True
+    elif TreasuryWallet.check_membership(tx.from_address.address, tx.block) and tx.to_address == ZERO_ADDRESS and tx.symbol == "yvCurve-DOLA-U":  # type: ignore [union-attr, arg-type]
+        return True
+    return False
+
+
+@vaults("DOLA FRAX Vault Withdrawal")
+def is_dola_frax_withdrawal(tx: TreasuryTx) -> bool:
+    symbol = tx.symbol
+    from_nickname = tx.from_nickname
+    to_nickname = tx.to_nickname
+    if (
+        symbol == "yvCurve-DOLA-FRAXBP-U"
+        and from_nickname == "Yearn yChad Multisig"
+        and to_nickname == "Zero Address"
+    ):
+        return True
+    elif (
+        symbol == "DOLAFRAXBP3CRV-f"
+        and from_nickname == "Token: Curve DOLA-FRAXBP Pool yVault - Unlisted"
+        and to_nickname == "Yearn yChad Multisig"
+    ):
+        return True
+    return (
+        tx.hash == "0x59a3a3b9e724835958eab6d0956a3acf697191182c41403c96d39976047d7240"
+        and tx.log_index == 232
+    )

yearn_treasury/rules/ignore/swaps/woofy.py

@@ -0,0 +1,80 @@
+from decimal import Decimal
+from typing import Final
+
+from brownie import ZERO_ADDRESS
+from dao_treasury import TreasuryTx
+from y import Network
+
+from yearn_treasury.constants import YFI
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+WOOFY: Final = "0xD0660cD418a64a1d44E9214ad8e459324D8157f1"
+
+YFI_SCALE: Final = Decimal(10**18)
+WOOFY_SCALE: Final = Decimal(10**12)
+
+
+@swaps("WOOFY", Network.Mainnet)
+def is_woofy(tx: TreasuryTx) -> bool:
+    """
+    Returns True if the tx involved wrapping or unwrapping WOOFY.
+
+    https://docs.yearn.fi/resources/deprecated/woofy
+    """
+
+    # Wrapping, YFI side
+    if tx.to_address == WOOFY and tx.symbol == "YFI":
+        # Check for WOOFY transfer
+        for transfer in tx.get_events("Transfer"):
+            if transfer.address != WOOFY:
+                continue
+            sender, receiver, amount = transfer.values()
+            if sender == ZERO_ADDRESS and tx.from_address == receiver:
+                scaled = Decimal(amount) / YFI_SCALE
+                if scaled == tx.amount:
+                    return True
+                print(f"woofy wrapping woofy side amount no match: [{scaled}, {tx.amount}]")
+
+    # Wrapping, WOOFY side
+    elif tx.from_address == ZERO_ADDRESS and tx.symbol == "WOOFY":
+        # Check for YFI transfer
+        for transfer in tx.get_events("Transfer"):
+            if transfer.address != YFI:
+                continue
+            sender, receiver, amount = transfer.values()
+            if receiver == WOOFY and tx.to_address == sender:
+                scaled = Decimal(amount) / WOOFY_SCALE
+                if scaled == tx.amount:
+                    return True
+                print(f"woofy wrapping yfi side amount no match: [{scaled}, {tx.amount}]")
+
+    # Unwrapping, YFI side
+    elif tx.from_address == WOOFY and tx.symbol == "YFI":
+        # Check for WOOFY transfer
+        for transfer in tx.get_events("Transfer"):
+            if transfer.address != WOOFY:
+                continue
+            sender, receiver, amount = transfer.values()
+            if tx.to_address == sender and receiver == ZERO_ADDRESS:
+                scaled = round(Decimal(amount) / YFI_SCALE, 12)
+                rounded = round(tx.amount, 12)
+                if scaled == rounded:
+                    return True
+                print(f"woofy unwrapping yfi side amount no match: [{scaled}, {rounded}]")
+
+    # Unwrapping, WOOFY side
+    elif tx.to_address == ZERO_ADDRESS and tx.symbol == "WOOFY":
+        # Check for YFI transfer
+        for transfer in tx.get_events("Transfer"):
+            if transfer.address != YFI:
+                continue
+            sender, receiver, amount = transfer.values()
+            if sender == WOOFY and tx.from_address == receiver:
+                # TODO remove this rounding once sqlite is replaced with postgres
+                scaled = round(Decimal(amount) / WOOFY_SCALE, 7)
+                rounded = round(tx.amount, 7)
+                if scaled == rounded:
+                    return True
+                print(f"woofy unwrapping woofy side amount no match: [{scaled}, {rounded}]")
+    return False

yearn_treasury/rules/ignore/swaps/yfi.py

@@ -0,0 +1,111 @@
+import decimal
+from typing import Final
+
+from brownie.exceptions import EventLookupError
+from dao_treasury import TreasuryTx
+from y import WRAPPED_GAS_COIN, Network
+
+from yearn_treasury.constants import YCHAD_MULTISIG
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+buying_yfi: Final = swaps("Buying YFI")
+
+VYPER_BUYERS: Final = (
+    "0xdf5e4E54d212F7a01cf94B3986f40933fcfF589F",  # buys YFI for DAI at the current chainlink price
+    "0x6903223578806940bd3ff0C51f87aa43968424c8",  # buys YFI for DAI at the current chainlink price. Can be funded via llamapay stream.
+)
+"""These contracts, now retired, previously were used to purchase YFI for DAI at the current chainlink market price."""
+
+
+YFI_BUYBACK_AUCTIONS: Final = "0x4349ed200029e6Cf38F1455B9dA88981F1806df3"
+
+
+Decimal: Final = decimal.Decimal
+
+
+@buying_yfi("Top-up Buyer Contract", Network.Mainnet)
+def is_buyer_top_up(tx: TreasuryTx) -> bool:
+    """
+    The sell side of these transactions is in :func:`is_buying_with_buyer`.
+    The buyer is topped up with DAI regularly and buys YFI at the current chainlink market price.
+
+    # TODO: amortize this into a daily expense
+    """
+    return tx.symbol == "DAI" and tx.to_address.address in VYPER_BUYERS  # type: ignore [union-attr]
+
+
+@buying_yfi("Buyer Contract", Network.Mainnet)
+def is_buying_with_buyer(tx: TreasuryTx) -> bool:
+    """
+    The buy side of these transactions is in :func:`is_buyer_top_up`.
+    The buyer is topped up with DAI regularly and buys YFI at the current chainlink market price
+    """
+    if tx.symbol == "YFI" and tx.to_address.address == YCHAD_MULTISIG:  # type: ignore [union-attr]
+        try:
+            events = tx.events
+        except KeyError as e:
+            if "components" in str(e):
+                print(f"cannot parse events of possible YFI buyback {tx}")
+                return False
+            raise
+
+        if "Buyback" in events:
+            buyback_events = events["Buyback"]
+            if len(buyback_events) > 1:
+                print(f"Must code handler for multiple Buyback events in one tx: {tx}")
+                return False
+            buyback_event = buyback_events[0]
+            if buyback_event.address in VYPER_BUYERS and all(  # type: ignore [attr-defined]
+                arg in buyback_event for arg in ("buyer", "yfi", "dai")
+            ):
+                # TODO get rid of this rounding once we've swapped out sqlite for postgres
+                buyback_amount = Decimal(buyback_event["yfi"]) / 10**18  # type: ignore [call-overload]
+                if round(tx.amount, 14) == round(buyback_amount, 14):
+                    return True
+                print(
+                    f"from node: {buyback_amount} "
+                    f"from db: {tx.amount} "
+                    f"diff: {buyback_amount - tx.amount}"
+                )
+            else:
+                print("unhandled Buyback event: buyback_event")
+    return False
+
+
+@buying_yfi("Buyback Auction", Network.Mainnet)
+def is_buying_with_auction(tx: TreasuryTx) -> bool:
+    try:
+        if tx.symbol != "YFI" or tx.to_address != YCHAD_MULTISIG or "AuctionTaken" not in tx.events:
+            return False
+    except EventLookupError:
+        return False
+    except KeyError as e:
+        # TODO: diagnose and fix this, pretty sure it's in eth-event
+        if "components" not in str(e):
+            raise
+        return False
+
+    auctions_taken = tx.get_events("AuctionTaken")
+    if len(auctions_taken) == 0:
+        return False
+    if len(auctions_taken) > 1:
+        raise NotImplementedError("we need new code to handle this case")
+    event = auctions_taken[0]
+    if event.address != YFI_BUYBACK_AUCTIONS:  # type: ignore [attr-defined]
+        raise ValueError(event.address, event)  # type: ignore [attr-defined]
+    # did the auction contract send weth to tx.sender?
+    for transfer in tx.get_events("Transfer"):
+        if transfer.address == WRAPPED_GAS_COIN:
+            sender, receiver, amount = transfer.values()
+            if sender != YFI_BUYBACK_AUCTIONS:
+                print(f"Transfer sender is not YFI_BUYBACK_AUCTIONS:  sender={sender}  YFI_BUYBACK_AUCTIONS={YFI_BUYBACK_AUCTIONS}")  # type: ignore [union-attr]
+                continue
+            if tx.from_address != receiver:
+                print(f"Transfer does not match auction taker:  taker={tx.from_address.address}  transfer={receiver}")  # type: ignore [union-attr]
+                continue
+            # TODO get rid of this rounding once we've swapped out sqlite for postgres
+            if round(amount, 14) == round(event["taken"], 14):  # type: ignore [call-overload]
+                return True
+            print(f"AuctionTaken: {event} amount does not match Transfer: {transfer}")
+    return False

yearn_treasury/rules/ignore/swaps/yla.py

@@ -0,0 +1,28 @@
+from typing import Final
+
+from dao_treasury import TreasuryTx
+from y import Network
+
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+yla: Final = swaps("Yearn Lazy Ape")
+
+
+@yla("Deposit", Network.Mainnet)
+def is_yla_deposit(tx: TreasuryTx) -> bool:
+    return tx.hash == "0x1d4e974db2d60ebd994410fcd793c5db771af9a14660015faf94cbdaec285009" and (
+        tx.symbol == "YLA" or tx.to_address.address == "0x9ba60bA98413A60dB4C651D4afE5C937bbD8044B"  # type: ignore [union-attr]
+    )
+
+
+@yla("Withdrawal", Network.Mainnet)
+def is_yla_withdrawal(tx: TreasuryTx) -> bool:
+    return (
+        "0x85c6D6b0cd1383Cc85e8e36C09D0815dAf36b9E9"
+        in (
+            tx.from_address.address,  # type: ignore [union-attr]
+            tx.to_address.address,  # type: ignore [union-attr]
+        )
+        or tx.hash == "0xb1ed399c268dfaf9917e20270cb720ab95986630b6cd4cabd7f02bb55ad5f7c6"
+    )

yearn_treasury/rules/ignore/unit.py

@@ -0,0 +1,40 @@
+"""
+Ignore rules for Unit.xyz protocol.
+
+This module defines matching logic for Unit.xyz protocol transactions,
+so they can be ignored in analytics and reporting.
+"""
+
+from typing import Final
+
+from dao_treasury import TreasuryTx, ignore
+from y import Network
+
+from yearn_treasury.constants import ZERO_ADDRESS
+
+
+UNIT_XYZ_VAULT: Final = "0xb1cFF81b9305166ff1EFc49A129ad2AfCd7BCf19"
+
+unit: Final = ignore("Unit.xyz")
+collateral: Final = unit("Collateral")
+usdp: Final = unit("USDP")
+
+
+@collateral("YFI Deposit", Network.Mainnet)
+def is_unit_yfi_deposit(tx: TreasuryTx) -> bool:
+    return tx.symbol == "YFI" and tx.to_address.address == UNIT_XYZ_VAULT  # type: ignore [union-attr]
+
+
+@collateral("YFI Withdrawal", Network.Mainnet)
+def is_unit_yfi_withdrawal(tx: TreasuryTx) -> bool:
+    return tx.symbol == "YFI" and tx.from_address.address == UNIT_XYZ_VAULT  # type: ignore [union-attr]
+
+
+@usdp("Minting", Network.Mainnet)
+def is_minting_usdp(tx: TreasuryTx) -> bool:
+    return tx.symbol == "USDP" and tx.from_address.address == ZERO_ADDRESS  # type: ignore [union-attr]
+
+
+@usdp("Burning", Network.Mainnet)
+def is_burning_usdp(tx: TreasuryTx) -> bool:
+    return tx.symbol == "USDP" and tx.to_address.address == ZERO_ADDRESS  # type: ignore [union-attr]

yearn_treasury/rules/ignore/weth.py

@@ -1,3 +1,11 @@
+"""
+Ignore rules for WETH minting and burning.
+
+This module defines matching logic for WETH minting and burning
+transactions, so those transactions can be ignored in analytics
+and reporting.
+"""
+
 from typing import Final
 
 import y
@@ -14,12 +22,12 @@ weth: Final[ChecksumAddress] = y.weth.address  # type: ignore [assignment]
 def is_weth_mint(tx: TreasuryTx) -> bool:
     if (
         tx.from_address == ZERO_ADDRESS
-        and TreasuryWallet._get_instance(tx.to_address.address)  # type: ignore [union-attr, arg-type]
+        and TreasuryWallet.check_membership(tx.to_address.address, tx.block)  # type: ignore [union-attr, arg-type]
         and tx.token == weth
     ):
         return True
     return bool(
-        TreasuryWallet._get_instance(tx.from_address.address)  # type: ignore [union-attr, arg-type]
+        TreasuryWallet.check_membership(tx.from_address.address, tx.block)  # type: ignore [union-attr, arg-type]
         and tx.to_address == weth
         and tx.token == EEE_ADDRESS
     )
@@ -28,13 +36,13 @@ def is_weth_mint(tx: TreasuryTx) -> bool:
 @ignore("WETH:Burning")
 def is_weth(tx: TreasuryTx) -> bool:
     if (
-        TreasuryWallet._get_instance(tx.from_address.address)  # type: ignore [union-attr, arg-type]
+        TreasuryWallet.check_membership(tx.from_address.address, tx.block)  # type: ignore [union-attr, arg-type]
         and tx.to_address == ZERO_ADDRESS
         and tx.token == weth
     ):
         return True
     return bool(
         tx.from_address == weth
-        and TreasuryWallet._get_instance(tx.to_address.address)  # type: ignore [union-attr, arg-type]
+        and TreasuryWallet.check_membership(tx.to_address.address, tx.block)  # type: ignore [union-attr, arg-type]
         and tx.token == EEE_ADDRESS
     )

yearn_treasury/rules/other_expense/__init__.py

@@ -1,5 +1,6 @@
 from yearn_treasury.rules.other_expense.boost import *
 from yearn_treasury.rules.other_expense.bugs import *
+from yearn_treasury.rules.other_expense.donations import *
 from yearn_treasury.rules.other_expense.dyfi import *
 from yearn_treasury.rules.other_expense.events import *
 from yearn_treasury.rules.other_expense.misc import *

yearn_treasury/rules/other_expense/donations.py

@@ -0,0 +1,43 @@
+"""
+Other expense rules for donations in Yearn Treasury.
+
+This module defines matching logic for donation transactions,
+including Gitcoin matching rounds, 4626 Alliance, Vyper Compiler
+Audit Contest, Warroom Games, and more.
+"""
+
+from typing import Final
+
+from dao_treasury import TreasuryTx, other_expense
+from y import Network
+
+
+donations: Final = other_expense("Donations")
+
+gitcoin: Final = "0xde21F729137C5Af1b01d73aF1dC21eFfa2B8a0d6"
+
+
+@donations("Gitcoin Matching Round", Network.Mainnet)
+def is_gitcoin_matching_donation(tx: TreasuryTx) -> bool:
+    return tx.symbol in ["DAI", "USDC"] and tx.to_address == gitcoin
+
+
+donations("4626 Alliance", Network.Mainnet).match(
+    hash="0xca61496c32806ba34f0deb331c32969eda11c947fdd6235173e6fa13d9a1c288",
+    log_index=150,
+)
+
+
+donations("Vyper Compiler Audit Contest", Network.Mainnet).match(
+    # Grant for a vyper compiler audit context, vyper-context.eth
+    hash="0xb8bb3728fdfb49d7c86c08dba8e3586e3761f13d2c88fa6fab80227b6a3f4519",
+    log_index=202,
+)
+
+
+@donations("Warroom Games 2023 Prizes", Network.Mainnet)
+def is_warroom_games(tx: TreasuryTx) -> bool:
+    return (
+        tx.hash == "0x8f17ead9cea87166cf99ed2cdbc46dfdf98c04c261de5b5167caddce5f704cb2"
+        and tx.log_index in [429, 430, 431]
+    )

yearn_treasury/rules/other_expense/events.py

@@ -7,6 +7,12 @@ from y import Network
 events: Final = other_expense("Events")
 
 
+events("Devcon").match(
+    hash="0x57bc99f6007989606bdd9d1adf91c99d198de51f61d29689ee13ccf440b244df",
+    log_index=83,
+)
+
+
 @events("EthDenver", Network.Mainnet)
 def is_eth_denver(tx: TreasuryTx) -> bool:
     return (

yearn_treasury/rules/other_expense/match_on_to_address.yaml

@@ -3,5 +3,6 @@
     - "0x93C6c14C134C4fF52cbB6BC2f50F19d84874cDD1"
   Aztek Gas Subsidy:
     - "0xABc30E831B5Cc173A9Ed5941714A7845c909e7fA"
-  Vyper Donation:
-    - "0x70CCBE10F980d80b7eBaab7D2E3A73e87D67B775"
+  Donations:
+    Vyper:
+      - "0x70CCBE10F980d80b7eBaab7D2E3A73e87D67B775"