yearn-treasury 0.0.8__cp310-cp310-win_amd64.whl → 0.0.48__cp310-cp310-win_amd64.whl

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",
+    }

yearn_treasury/rules/ignore/swaps/curve.py

@@ -0,0 +1,170 @@
+from typing import Final
+
+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
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+curve: Final = swaps("Curve")
+
+
+# curve helpers
+@alru_cache(maxsize=None)
+async def _get_lp_token(pool: Contract) -> ChecksumAddress:
+    return ChecksumAddress(await pool.lp_token)
+
+
+async def _is_old_style(tx: TreasuryTx, pool: Contract) -> bool:
+    return hasattr(pool, "lp_token") and tx.token == await _get_lp_token(pool)
+
+
+def _is_new_style(tx: TreasuryTx, pool: Contract) -> bool:
+    return hasattr(pool, "totalSupply") and tx.token == pool.address
+
+
+def _token_is_curvey(tx: TreasuryTx) -> bool:
+    return "crv" in tx.symbol.lower() or "curve" in tx.token.name.lower()
+
+
+@alru_cache(maxsize=None)
+async def _get_coin_at_index(pool: Contract, index: int) -> ChecksumAddress:
+    return ChecksumAddress(await pool.coins.coroutine(index))
+
+
+@curve("Adding Liquidity")
+async def is_curve_deposit(tx: TreasuryTx) -> bool:
+    pool: Contract
+    for event in tx.get_events("AddLiquidity"):
+        # LP Token Side
+        if tx.from_address == ZERO_ADDRESS and _token_is_curvey(tx):
+            pool = await Contract.coroutine(event.address)  # type: ignore [assignment]
+            if await _is_old_style(tx, pool) or _is_new_style(tx, pool):
+                return True
+
+        # Tokens sent
+        elif tx.to_address == event.address:
+            try:
+                tx_amount = round(tx.amount, 8)
+                for i, amount in enumerate(event["token_amounts"]):
+                    # 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
+
+        # What if a 3crv deposit was needed before the real deposit?
+        elif (
+            TreasuryWallet.check_membership(tx.from_address.address, tx.block)  # type: ignore [union-attr, arg-type]
+            and tx.to_address == "0xA79828DF1850E8a3A3064576f380D90aECDD3359"
+            and event.address == "0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7"
+        ):
+            print(f"AddLiquidity-3crv: {event}")
+            token = tx.token
+            for i, amount in enumerate(event["token_amounts"]):
+                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 (
+        "0x567d2ebc1a336185950432b8f8b010e1116936f9e6c061634f5aba65bdb1e188",
+        "0x17e2d7a40697204b3e726d40725082fec5f152f65f400df850f13ef4a4f6c827",
+    )
+
+
+@curve("Removing Liquidity")
+async def is_curve_withdrawal(tx: TreasuryTx) -> bool:
+    return (
+        _is_curve_withdrawal_one(tx)
+        or await _is_curve_withdrawal_multi(tx)
+        or (
+            CHAINID == Network.Mainnet
+            and tx.hash
+            in (
+                # This was a one-off withdrawal from a special pool 0x5756bbdDC03DaB01a3900F01Fb15641C3bfcc457
+                "0xe4f7c8566944202faed1d1e190e400e7bdf8592e65803b09510584ca5284d174",
+            )
+        )
+    )
+
+
+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):
+            # 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
+        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
+
+
+async def _is_curve_withdrawal_multi(tx: TreasuryTx) -> bool:
+    pool: Contract
+    for event in tx.get_events("RemoveLiquidity"):
+        # LP Token side
+        if tx.to_address == ZERO_ADDRESS and _token_is_curvey(tx):
+            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"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"]):
+                    # 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"):
+                            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
+    return False

yearn_treasury/rules/ignore/swaps/gearbox.py

@@ -0,0 +1,37 @@
+"""
+Ignore rules for Gearbox protocol transactions.
+
+This module defines matching logic for Gearbox protocol deposit and
+withdrawal swaps, so these transactions can be filtered from analytics
+and reporting.
+"""
+
+from dao_treasury import TreasuryTx
+from y import Network
+
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+gearbox = swaps("Gearbox")
+
+
+@gearbox("Deposit", Network.Mainnet)
+def is_gearbox_deposit(tx: TreasuryTx) -> bool:
+    txhash = tx.hash
+    log_index = tx.log_index
+    return (
+        txhash == "0x5666b03add778468482fb376e65761128f9f5051b487f3efc996a55c3620d6d4"
+        and log_index in (366, 367)
+    ) or (
+        txhash == "0x9e113dda11fcd758df2fe94a641aa7afe6329afec4097a8cb5d6fb68489cf7d8"
+        and log_index in (74, 75)
+    )
+
+
+@gearbox("Withdrawal", Network.Mainnet)
+def is_gearbox_withdrawal(tx: TreasuryTx) -> bool:
+    txhash = tx.hash
+    return txhash == "0xb98d8f4dd3d9de50e6fec700fb8e5a732e5a564b7edfe365f97e601694536bb5" or (
+        txhash == "0x1d9e7930d0bf6725a4ffff43e284dfa9d10e34e16460e75d01a7f05a98e252a6"
+        and tx.log_index in (212, 213)
+    )

yearn_treasury/rules/ignore/swaps/iearn.py

@@ -0,0 +1,43 @@
+# mypy: disable-error-code=dict-item
+from typing import Dict, Final, cast
+
+from dao_treasury import TreasuryTx
+from eth_typing import ChecksumAddress
+from y import Contract, Network
+
+from yearn_treasury.constants import ZERO_ADDRESS
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+IEARN: Final[Dict[str, ChecksumAddress]] = {
+    # v1 - deprecated
+    # v2
+    "yDAIv2": "0x16de59092dAE5CcF4A1E6439D611fd0653f0Bd01",
+    "yUSDCv2": "0xd6aD7a6750A7593E092a9B218d66C0A814a3436e",
+    "yUSDTv2": "0x83f798e925BcD4017Eb265844FDDAbb448f1707D",
+    "ysUSDv2": "0xF61718057901F84C4eEC4339EF8f0D86D2B45600",
+    "yTUSDv2": "0x73a052500105205d34daf004eab301916da8190f",
+    "yWBTCv2": "0x04Aa51bbcB46541455cCF1B8bef2ebc5d3787EC9",
+    # v3
+    "yDAIv3": "0xC2cB1040220768554cf699b0d863A3cd4324ce32",
+    "yUSDCv3": "0x26EA744E5B887E5205727f55dFBE8685e3b21951",
+    "yUSDTv3": "0xE6354ed5bC4b393a5Aad09f21c46E101e692d447",
+    "yBUSDv3": "0x04bC0Ab673d88aE9dbC9DA2380cB6B79C4BCa9aE",
+}
+
+POOLS: Final = set(IEARN.values())
+
+POOL_TO_UNDERLYING: Final[Dict[ChecksumAddress, ChecksumAddress]] = {
+    pool: ChecksumAddress(Contract(pool).token()) for pool in POOLS
+}
+
+
+@swaps("iEarn:Withdrawal", Network.Mainnet)
+def is_iearn_withdrawal(tx: TreasuryTx) -> bool:
+    # Vault side
+    if tx.to_address == ZERO_ADDRESS:
+        return tx.token_address in POOLS
+    # Token side
+    from_address = cast(ChecksumAddress, tx.from_address.address)
+    token_address = tx.token_address
+    return POOL_TO_UNDERLYING.get(from_address) == token_address

yearn_treasury/rules/ignore/swaps/otc.py

@@ -0,0 +1,58 @@
+from typing import Final
+
+from dao_treasury import TreasuryTx
+from y import Network
+
+from yearn_treasury.constants import CHAINID
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+@swaps("OTC")
+def is_otc_swap(tx: TreasuryTx) -> bool:
+    txhash = tx.hash
+    log_index = tx.log_index
+    for otc_swap in _OTC_SWAPS:
+        if isinstance(otc_swap, tuple):
+            if txhash == otc_swap[0] and log_index in otc_swap[1]:
+                return True
+        else:
+            if txhash == otc_swap:
+                return True
+    return False
+
+
+_OTC_SWAPS: Final = {
+    Network.Mainnet: (
+        "0xd59dfba383c0a7d5f0e30124888fa6d9c2c964755fb9bed8f22483feb292c1e9",
+        "0xa00430b408c75dc432fcc0bbcabc5c3c63196addab532eecd233f6e80b295990",
+        "0x3419d8378321b5cb59c69584693ef59a65aeee4591e7e96c31f31906bc9a627a",
+        "0x30afed767aafd21696242c6a54576afc6598e976b969ffe50591360c729ef35a",
+        # Emergency dump of yvUSDN
+        "0xb22e345f58d7fe40257e41bac5d59ca74af8f6cc1e220aedf6f97113e4ace53a",
+        "0xd6bcaf0f144201d5c6affd73746ae57a262dbf00b957534a7b22bc0473bd589b",
+        # deprecated vault tokens
+        "0xf60060f25ae9f7d377741cde14d374a665dc8f1bff44f6fb231a1d89ac403711",
+        # ~8900 USDC sent back
+        "0xce4a854560f5b8f5d1790b7828ce90147eafee2f75cfc4009581977eebff8d51",
+        # "I moved them I moved them from yTrades to my EOA to dump since the liquidity was insanely small for OGV (mega price impact on cowswap) and there wasn't enough of VEC to justify cowswap"
+        # "I sold them to eth over time in my deployer EOA and am just gonna use it for gas"
+        "0x4713d14c624e0d4489980c91d3dc19fe468a9f0ad9c9b90fe4b7e55d9e67034e",
+        # vault tokens sent to swapper msig
+        (
+            "0xae7d281b8a093da60d39179452d230de2f1da4355df3aea629d969782708da5d",
+            (258, 262, 267, 272, 276),
+        ),
+        # ~9136 crvUSD returned to treasury
+        "0xac1f2a5e2960577e54c4a9cd096763cb6df614aa28eff221aeb4159097d9fa0f",
+        # ~8112 USDC returned to treasury
+        "0x015cdac2a021a44404c56600a96acfe2cb768e8789031b150be51db18874ec77",
+        # one-off dumping 1INCH (on 1INCH not otc but this works)
+        "0x037477c516652437004050e955edb6bc0de82a6b0f03e7665009e802c196516f",
+        # not otc swap, but swapped by 0x444 so close enough
+        ("0xd7e7abe600aad4a3181a3a410bef2539389579d2ed28f3e75dbbf3a7d8613688", (558, 559)),
+        "0x5a65d5299864ae6db364ee6a459a4f50d19e6fa8892f4f4c0221372b6c9b3ca2",
+        "0x71bd987e89940185b1131a6b73b981f5716c767ac12d106bf226a1aa8880f7c8",
+    ),
+}.get(
+    CHAINID, ()
+)  # type: ignore [call-overload]

yearn_treasury/rules/ignore/swaps/pooltogether.py

@@ -0,0 +1,23 @@
+"""
+Ignore rules for PoolTogether protocol transactions.
+
+This module defines matching logic for PoolTogether deposits swaps,
+as they can be safely ignored in analytics and reporting.
+"""
+
+from dao_treasury import TreasuryTx
+from y import Network
+
+from yearn_treasury.constants import ZERO_ADDRESS
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+@swaps("PoolTogether:Deposit", Network.Mainnet)
+def is_pooltogether_deposit(tx: TreasuryTx) -> bool:
+    # TODO: figure out what was done with the withdrawals and put a note here
+    symbol = tx.symbol
+    return (
+        symbol == "POOL" and tx.to_address.address == "0x396b4489da692788e327E2e4b2B0459A5Ef26791"
+    ) or (  # type: ignore [union-attr]
+        symbol == "PPOOL" and tx.from_address.address == ZERO_ADDRESS
+    )  # type: ignore [union-attr]

yearn_treasury/rules/ignore/swaps/synthetix.py

@@ -0,0 +1,10 @@
+from dao_treasury import TreasuryTx
+from y import Network
+
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+@swaps("Synthetix", Network.Mainnet)
+def is_synthetix_swap(tx: TreasuryTx) -> bool:
+    # TODO Figure out hueristics for sorting these if they become more frequent
+    return tx.hash == "0x5a55121911d9a3992fc1ea9504da9b86331da2148822d88c16f805b2c6b2c753"