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

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"

yearn_treasury/rules/ignore/swaps/uniswap.py

@@ -57,7 +57,7 @@ async def is_uniswap_deposit(tx: TreasuryTx) -> bool:
                         if any(
                             tokens[1] == transfer.address
                             and tx.to_address
-                            == transfer.values()[:1]
+                            == transfer.values()[:1]  # type: ignore [index]
                             == [mint["sender"], mint.address]
                             for transfer in transfers
                         ):
@@ -78,7 +78,7 @@ async def is_uniswap_deposit(tx: TreasuryTx) -> bool:
                         if any(
                             tokens[0] == transfer.address
                             and tx.to_address
-                            == transfer.values()[:1]
+                            == transfer.values()[:1]  # type: ignore [index]
                             == [mint["sender"], mint.address]
                             for transfer in transfers
                         ):
@@ -190,6 +190,9 @@ async def is_uniswap_withdrawal(tx: TreasuryTx) -> bool:
     return CHAINID == Network.Mainnet and tx.hash in (
         "0xf0723677162cdf8105c0f752a8c03c53803cb9dd9a6649f3b9bc5d26822d531f",
         "0xaf1b7f138fb8bf3f5e13a680cb4a9b7983ec71a75836111c03dee6ae530db176",  # v3
+        # these use ETH not WETH so they dont match
+        "0x5b05dfd3305c471df0ad944237edc2dbb14b268f7415252de566a5ab283002af",
+        "0x46ab9b383751f612ea0de8c0c6e9fa86e7324de04b032ecb48161989b7dbdbf7",
     )
 
 
@@ -240,11 +243,21 @@ async def is_uniswap_swap(tx: TreasuryTx) -> bool:
                 continue
 
             if tx.token == token0:
-                if tx.token.scale_value(swap["amount0In"]) == tx.amount:
+                # TODO: get rid of this rounding when we migrate to postgres
+                event_amount = round(tx.token.scale_value(swap["amount0In"]), 10)
+                if event_amount == round(tx.amount, 10):
                     return True
+                print(
+                    f"Uniswap sell token0 amount does not match: {round(tx.amount, 10)}  {event_amount}"
+                )
             elif tx.token == token1:
-                if tx.token.scale_value(swap["amount1In"]) == tx.amount:
+                # TODO: get rid of this rounding when we migrate to postgres
+                event_amount = round(tx.token.scale_value(swap["amount1In"]), 10)
+                if event_amount == round(tx.amount, 10):
                     return True
+                print(
+                    f"Uniswap sell token1 amount does not match: {round(tx.amount, 10)}  {event_amount}"
+                )
 
         # Buy side
         elif tx.from_address == swap.address and TreasuryWallet._get_instance(
@@ -259,11 +272,21 @@ async def is_uniswap_swap(tx: TreasuryTx) -> bool:
                 # This will be recorded elsewhere
                 continue
             if "amount0Out" in swap and tx.token == token0:
-                if tx.token.scale_value(swap["amount0Out"]) == tx.amount:
+                # TODO: get rid of this rounding when we migrate to postgres
+                event_amount = round(tx.token.scale_value(swap["amount0Out"]), 9)
+                if event_amount == round(tx.amount, 9):
                     return True
+                print(
+                    f"Uniswap buy token0 amount does not match: {round(tx.amount, 9)}  {event_amount}"
+                )
             elif "amount1Out" in swap and tx.token == token1:
-                if tx.token.scale_value(swap["amount1Out"]) == tx.amount:
+                # TODO: get rid of this rounding when we migrate to postgres
+                event_amount = round(tx.token.scale_value(swap["amount1Out"]), 10)
+                if event_amount == round(tx.amount, 10):
                     return True
+                print(
+                    f"Uniswap buy token1 amount does not match: {round(tx.amount, 10)}  {event_amount}"
+                )
     return False
 
 

yearn_treasury/rules/ignore/swaps/unwrapper.py

@@ -0,0 +1,17 @@
+"""
+Ignore rules for the Unwrapper contract.
+
+This module defines matching logic for swaps involving the Unwrapper
+contract, so those transactions can be ignored from analytics and
+reporting.
+"""
+
+from dao_treasury import TreasuryTx
+from y import Network
+
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+@swaps("Unwrapper", Network.Mainnet)
+def is_unwrapper(tx: TreasuryTx) -> bool:
+    return "Contract: Unwrapper" in [tx.from_nickname, tx.to_nickname]