yearn-treasury 0.0.44__cp310-cp310-win32.whl

yearn_treasury/rules/ignore/swaps/uniswap.py

@@ -0,0 +1,294 @@
+from typing import Final
+
+from brownie import ZERO_ADDRESS, chain
+from dao_treasury import TreasuryTx, TreasuryWallet
+from y import Network, Contract
+from y.constants import CHAINID, WRAPPED_GAS_COIN
+
+from yearn_treasury.rules.ignore.swaps import swaps
+from yearn_treasury.rules.ignore.swaps._skip_tokens import SKIP_TOKENS
+
+
+uniswap: Final = swaps("Uniswap")
+
+
+ROUTERS: Final = ("0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F",)
+
+
+@uniswap("Add Liquidity")
+async def is_uniswap_deposit(tx: TreasuryTx) -> bool:
+    if tx.to_address:
+        try:
+            events = tx.events
+        except KeyError as e:
+            if e.args[0] == "components":
+                return False
+            raise
+
+        if "Mint" in events and "Transfer" in events:
+            transfers = events["Transfer"]
+            for mint in events["Mint"]:
+                event_args = {"sender", "amount0", "amount1"}
+                if any(arg not in mint for arg in event_args):
+                    continue
+
+                # LP token
+                if tx.from_address == ZERO_ADDRESS and (
+                    tx.token == mint.address
+                    or
+                    # KP3R/WETH Uni v3 LP -- used while depositing to kLP-KP3R/WETH
+                    mint.address == "0x11B7a6bc0259ed6Cf9DB8F499988F9eCc7167bf5"
+                ):
+                    lp = tx.token.contract
+                    tokens = [await lp.token0, await lp.token1]
+                    if all(
+                        any(
+                            token == transfer.address
+                            and tx.to_address == transfer[0]
+                            and transfer[1] == mint.address
+                            for transfer in events["Transfer"]
+                        )
+                        for token in tokens
+                    ):
+                        return True
+
+                    # Maybe native asset was used instead of wrapped.
+                    if tokens[0] == WRAPPED_GAS_COIN:
+                        if any(
+                            tokens[1] == transfer.address
+                            and tx.to_address
+                            == transfer.values()[:1]  # type: ignore [index]
+                            == [mint["sender"], mint.address]
+                            for transfer in transfers
+                        ):
+                            for int_tx in chain.get_transaction(tx.hash).internal_transfers:
+                                if (
+                                    tx.to_address == int_tx["from"] == mint["sender"]
+                                    and int_tx["to"] in ROUTERS
+                                ):
+                                    for transfer in transfers:
+                                        if (
+                                            transfer[0] == WRAPPED_GAS_COIN == transfer.address
+                                            and tx.token == transfer[1]
+                                            and transfer[2] == int_tx["value"]
+                                        ):
+                                            return True
+
+                    elif tokens[1] == WRAPPED_GAS_COIN:
+                        if any(
+                            tokens[0] == transfer.address
+                            and tx.to_address
+                            == transfer.values()[:1]  # type: ignore [index]
+                            == [mint["sender"], mint.address]
+                            for transfer in transfers
+                        ):
+                            for int_tx in chain.get_transaction(tx.hash).internal_transfers:
+                                if (
+                                    tx.to_address == int_tx["from"] == mint["sender"]
+                                    and int_tx["to"] in ROUTERS
+                                ):
+                                    for transfer in transfers:
+                                        if (
+                                            transfer[0] == WRAPPED_GAS_COIN == transfer.address
+                                            and tx.token == transfer[1]
+                                            and transfer[2] == int_tx["value"]
+                                        ):
+                                            return True
+
+                    else:
+                        print(f"tokens: {tokens}")
+
+                # Component tokens
+                elif tx.to_address == mint.address:
+                    return True
+
+    if CHAINID == Network.Mainnet:
+        return (
+            tx.hash == "0x3a000d3aa5d0d83a3ff359de261bfcecdc62cd13500b8ab517802742ac918627"
+        )  # uni v3
+    return False
+
+
+@uniswap("Remove Liquidity")
+async def is_uniswap_withdrawal(tx: TreasuryTx) -> bool:
+    if tx.to_address:
+        try:
+            events = tx.events
+        except KeyError as e:
+            if e.args[0] == "components":
+                return False
+            raise
+
+        if "Burn" in events and "Transfer" in events:
+            transfers = events["Transfer"]
+            for burn in events["Burn"]:
+                event_args = {"sender", "amount0", "amount1", "to"}
+                if any(arg not in burn for arg in event_args):
+                    continue
+
+                # LP token
+                if (
+                    TreasuryWallet._get_instance(tx.from_address.address)  # type: ignore [union-attr, arg-type]
+                    and tx.from_address == burn["to"]
+                    and tx.token == tx.to_address == burn.address
+                ):
+                    lp = tx.token.contract
+                    tokens = [await lp.token0, await lp.token1]
+                    if tx.token == tx.to_address and all(
+                        any(
+                            token == transfer.address
+                            and tx.to_address == transfer[0]
+                            and tx.from_address == transfer[1] == burn["to"]
+                            for transfer in transfers
+                        )
+                        for token in tokens
+                    ):
+                        return True
+
+                    # Maybe native asset was used instead of wrapped.
+                    if tokens[0] == WRAPPED_GAS_COIN:
+                        if any(
+                            tokens[1] == transfer.address
+                            and tx.token == tx.to_address == transfer[0]
+                            and tx.from_address == transfer[1] == burn["to"]
+                            for transfer in transfers
+                        ):
+                            for int_tx in chain.get_transaction(tx.hash).internal_transfers:
+                                if int_tx["from"] in ROUTERS and tx.from_address == int_tx["to"]:
+                                    for transfer in transfers:
+                                        if (
+                                            tx.token == transfer[0]
+                                            and transfer[1] == transfer.address == WRAPPED_GAS_COIN
+                                            and transfer[2] == int_tx["value"]
+                                        ):
+                                            return True
+
+                    elif tokens[1] == WRAPPED_GAS_COIN:
+                        if any(
+                            tokens[0] == transfer.address
+                            and tx.token == tx.to_address == transfer[0]
+                            and tx.from_address == transfer[1] == burn["to"]
+                            for transfer in transfers
+                        ):
+                            for int_tx in chain.get_transaction(tx.hash).internal_transfers:
+                                if int_tx["from"] in ROUTERS and tx.from_address == int_tx["to"]:
+                                    for transfer in transfers:
+                                        if (
+                                            transfer[0] == tx.token
+                                            and transfer[1] == transfer.address == WRAPPED_GAS_COIN
+                                            and transfer[2] == int_tx["value"]
+                                        ):
+                                            return True
+
+                    else:
+                        print(f"tokens: {tokens}")
+
+                # Component tokens
+                elif tx.from_address == burn.address:
+                    return True
+
+    return CHAINID == Network.Mainnet and tx.hash in (
+        "0xf0723677162cdf8105c0f752a8c03c53803cb9dd9a6649f3b9bc5d26822d531f",
+        "0xaf1b7f138fb8bf3f5e13a680cb4a9b7983ec71a75836111c03dee6ae530db176",  # v3
+        # these use ETH not WETH so they dont match
+        "0x5b05dfd3305c471df0ad944237edc2dbb14b268f7415252de566a5ab283002af",
+        "0x46ab9b383751f612ea0de8c0c6e9fa86e7324de04b032ecb48161989b7dbdbf7",
+    )
+
+
+@uniswap("Swap")
+async def is_uniswap_swap(tx: TreasuryTx) -> bool:
+    # The LP for dumping solidSEX is not verified :( devs blz do something
+    # Sell side
+    if (
+        TreasuryWallet._get_instance(tx.from_address.address)  # type: ignore [union-attr, arg-type]
+        and tx.to_nickname == "Non-Verified Contract: 0xa66901D1965F5410dEeB4d0Bb43f7c1B628Cb20b"
+        and tx.symbol == "SOLIDsex"
+    ):
+        return True
+    # Buy side
+    elif (
+        tx.from_nickname == "Non-Verified Contract: 0xa66901D1965F5410dEeB4d0Bb43f7c1B628Cb20b"
+        and TreasuryWallet._get_instance(tx.to_address.address)  # type: ignore [union-attr, arg-type]
+        and tx.symbol == "WFTM"
+    ):
+        return True
+
+    elif CHAINID == Network.Mainnet and tx.hash in (
+        # uni v3
+        "0x490245ef6e3c60127491415afdea23c13f4ca1a8c04de4fb3a498e7f7574b724",
+        "0xf2c6ff1863c60ca9924b611dad5548ffc4fecbab2fee34e2601dd16f0aa8e333",
+    ):
+        return True
+
+    # All other swaps
+    for swap in tx.get_events("Swap"):
+        # Sell side
+        if (
+            TreasuryWallet._get_instance(tx.from_address.address)  # type: ignore [union-attr, arg-type]
+            and tx.to_address == swap.address
+        ):
+            pool = await Contract.coroutine(swap.address)
+            if not is_pool(pool):  # type: ignore [arg-type]
+                continue
+
+            token0 = await pool.token0  # type: ignore [attr-defined]
+            token1 = await pool.token1  # type: ignore [attr-defined]
+            if token0 in SKIP_TOKENS or token1 in SKIP_TOKENS:
+                # This will be recorded elsewhere
+                continue
+
+            # The below code only works for v2 swaps, let's skip v3 swaps
+            if "sqrtPriceX96" in swap:
+                continue
+
+            if tx.token == token0:
+                # 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:
+                # 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(
+            tx.to_address.address  # type: ignore [union-attr, arg-type]
+        ):
+            pool = await Contract.coroutine(swap.address)
+            if not is_pool(pool):  # type: ignore [arg-type]
+                continue
+            token0 = await pool.token0  # type: ignore [attr-defined]
+            token1 = await pool.token1  # type: ignore [attr-defined]
+            if token0 in SKIP_TOKENS or token1 in SKIP_TOKENS:
+                # This will be recorded elsewhere
+                continue
+            if "amount0Out" in swap and tx.token == token0:
+                # 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:
+                # 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
+
+
+def is_pool(pool: Contract) -> bool:
+    return hasattr(pool, "token0") and hasattr(pool, "token1")

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]

yearn_treasury/rules/ignore/swaps/vaults.py

@@ -0,0 +1,263 @@
+from typing import Final
+
+from dao_treasury import TreasuryTx, TreasuryWallet
+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.address
+
+    block: BlockNumber = tx.block  # type: ignore [assignment]
+    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 = tx.from_address.address  # type: ignore [union-attr]
+            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 = tx.to_address.address  # type: ignore [union-attr]
+    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: ChecksumAddress = token.address.address  # type: ignore [assignment]
+    block: BlockNumber = tx.block  # type: ignore [assignment]
+
+    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