eth-protocols-py 0.1.4__py3-none-any.whl

eth_protocols/__init__.py

@@ -0,0 +1,13 @@
+from .helpers import DexPairHelper, PriceTracker
+from .tokens import ERC20
+from .uniswap_v2 import V2Factory, V2Pair
+from .uniswap_v3 import V3Pool
+
+__all__ = [
+    "DexPairHelper",
+    "PriceTracker",
+    "ERC20",
+    "V2Factory",
+    "V2Pair",
+    "V3Pool",
+]

eth_protocols/camelot_v3/__init__.py

@@ -0,0 +1,5 @@
+from .pool import CamelotV3Pool
+
+__all__ = [
+    "CamelotV3Pool",
+]

eth_protocols/camelot_v3/pool.py

@@ -0,0 +1,163 @@
+from decimal import Decimal
+from typing import cast
+
+from eth_protocols.tokens import ERC20
+from eth_protocols.types import DexPair
+from eth_rpc.types import BLOCK_STRINGS, MaybeAwaitable
+from eth_typeshed.camelot_v3 import CamelotV3Pool, GlobalState
+from eth_typeshed.erc20 import OwnerRequest
+from eth_typeshed.multicall import multicall
+from eth_typing import HexAddress
+from eth_utils import to_checksum_address
+from pydantic import PrivateAttr
+
+Q192 = Decimal(2**192)
+
+
+class CamelotV3Pool(DexPair):
+    _contract: CamelotV3Pool = PrivateAttr()
+
+    @classmethod
+    def load_static(
+        cls,
+        pair_address: HexAddress,
+        tokena: HexAddress,
+        tokenb: HexAddress,
+    ):
+        token0, token1 = (
+            (tokena, tokenb) if tokena.lower() < tokenb.lower() else (tokenb, tokena)
+        )
+        return cls(
+            token0=ERC20(address=token0),  # type: ignore
+            token1=ERC20(address=token1),  # type: ignore
+            pair_address=pair_address,
+        )
+
+    @classmethod
+    async def load_pair(
+        cls,
+        pair_address: HexAddress,
+    ):
+        # TODO: type hints don't work with pydantic validators
+        _contract = CamelotV3Pool(address=pair_address)
+        token0, token1, fee = await multicall.execute(
+            _contract.token0(),
+            _contract.token1(),
+        )
+
+        return cls(
+            token0=ERC20(address=token0),  # type: ignore
+            token1=ERC20(address=token1),  # type: ignore
+            pair_address=pair_address,  # type: ignore
+        )
+
+    def set_global_state(self, global_stage: GlobalState):
+        self._global_state = global_stage
+
+    def set_reserve0(self, reserve: int):
+        self._reserve0 = reserve
+
+    def set_reserve1(self, reserve: int):
+        self._reserve1 = reserve
+
+    def get_price(
+        self,
+        token: HexAddress,
+        block_number: int | BLOCK_STRINGS = "latest",
+    ) -> Decimal:
+        token = to_checksum_address(token)
+        assert token == self.token0.address or token == self.token1.address
+
+        if block_number:
+            global_state = self._contract.global_state().get(block_number=block_number)
+        else:
+            global_state = self._global_state
+
+        sqrt_price = global_state.price
+
+        return self.sqrt_price_x96_to_token_prices(
+            sqrt_price,
+            self.token0.sync.decimals(),
+            self.token1.sync.decimals(),
+            token == self.token0.address,
+        )
+
+    def get_other_token(self, token: HexAddress) -> HexAddress:
+        token = to_checksum_address(token)
+        if token == self.token0.address:
+            return self.token1.address
+        elif token == self.token1.address:
+            return self.token0.address
+        else:
+            raise ValueError(
+                f"{token=} cannot be found {self.token0.address=} {self.token1.address=}"
+            )
+
+    def get_reserves(
+        self, block_number: int | BLOCK_STRINGS = "latest", sync: bool = False
+    ) -> MaybeAwaitable[tuple[int, int]]:
+        if sync:
+            token0_reserves, token1_reserves = multicall.execute(
+                *self._construct_pair_balance_request(), sync=True
+            )
+            self.set_reserves(token0_reserves, token1_reserves)
+            return token0_reserves, token1_reserves
+
+        async def get_reserves() -> tuple[int, int]:
+            token0_reserves = await self.token0.balance_of(
+                self.pair_address, block_number=block_number
+            )
+            token1_reserves = await self.token1.balance_of(
+                self.pair_address, block_number=block_number
+            )
+            self.set_reserves(token0_reserves, token1_reserves)
+            return token0_reserves, token1_reserves
+
+        return get_reserves
+
+    @staticmethod
+    def sqrt_price_x96_to_token_prices(
+        sqrt_price_x96: int,
+        token0_decimals: int,
+        token1_decimals: int,
+        token0: bool = True,
+    ) -> Decimal:
+        num = Decimal(sqrt_price_x96 * sqrt_price_x96)
+        price1: Decimal = (
+            (num / Q192)
+            * (Decimal(10) ** token0_decimals)
+            / (Decimal(10) ** token1_decimals)
+        )
+        if token0:
+            return Decimal(price1)
+        return Decimal(1) / price1
+
+    def _construct_pair_balance_request(self):
+        return [
+            self.token0.raw.balance_of(
+                OwnerRequest(
+                    self.pair_address,
+                )
+            ),
+            self.token1.raw.balance_of(
+                OwnerRequest(
+                    self.pair_address,
+                )
+            ),
+        ]
+
+    @classmethod
+    async def get_all_reserves(
+        self, pools: list["V3Pool"], block_number: int | BLOCK_STRINGS = "latest"
+    ) -> list[tuple[int, int]]:
+        pool_calls = []
+        for pool in pools:
+            pool_calls.extend(pool._construct_pair_balance_request())
+        reserves = cast(
+            list[int],
+            await multicall.execute(
+                *pool_calls,
+                block_number=block_number,
+            ),
+        )
+        return [(reserves[i], reserves[i + 1]) for i in range(0, len(reserves), 2)]

eth_protocols/helpers/__init__.py

@@ -0,0 +1,9 @@
+from .dex_pairs import DexPairHelper
+from .multicall import MultiCallRequestHelper
+from .price_tracker import PriceTracker
+
+__all__ = [
+    "DexPairHelper",
+    "PriceTracker",
+    "MultiCallRequestHelper",
+]

eth_protocols/helpers/dex_pairs.py

@@ -0,0 +1,254 @@
+from itertools import combinations
+
+from eth_protocols.camelot_v3 import CamelotV3Pool
+from eth_protocols.uniswap_v2 import V2Pair
+from eth_protocols.uniswap_v3 import V3Pool
+from eth_rpc.types.primitives import uint24
+from eth_typeshed.camelot_v3 import CamelotV3Factory
+from eth_typeshed.camelot_v3 import GetPoolRequest as CamelotGetPoolRequest
+from eth_typeshed.constants import Factories, Tokens
+from eth_typeshed.erc20 import OwnerRequest
+from eth_typeshed.uniswap_v2 import GetPairRequest, UniswapV2Factory, UniswapV2Pair
+from eth_typeshed.uniswap_v3 import GetPoolRequest, UniswapV3Factory, UniswapV3Pool
+from eth_typeshed.utils import try_execute_with_setters
+from eth_typing import HexAddress
+from eth_utils import to_checksum_address
+from pydantic import BaseModel
+
+
+class DexPairHelper(BaseModel):
+
+    @staticmethod
+    def find_pair(
+        data: dict[HexAddress, list[V2Pair | V3Pool]],
+        addr: HexAddress,
+        paired_with: HexAddress,
+        fee_tiers: list[int],
+        uniswap_v2_factory_address: HexAddress,
+        uniswap_v3_factory_address: HexAddress,
+    ):
+        addr = to_checksum_address(addr)
+        paired_with = to_checksum_address(paired_with)
+        calls_list = [
+            (
+                UniswapV2Factory(address=uniswap_v2_factory_address).get_pair(
+                    GetPairRequest(token_a=addr, token_b=paired_with)
+                ),
+                lambda result, addr=addr, paired_with=paired_with: (
+                    data.setdefault(addr, []).append(
+                        V2Pair.load_static(
+                            pair_address=result,
+                            tokena=addr,
+                            tokenb=paired_with,
+                        )
+                    )
+                ),
+            ),
+        ]
+
+        for fee in fee_tiers:
+            calls_list.extend(
+                [
+                    (
+                        UniswapV3Factory(address=uniswap_v3_factory_address).get_pool(
+                            GetPoolRequest(
+                                token_a=addr,
+                                token_b=paired_with,
+                                fee=uint24(fee),
+                            )
+                        ),
+                        lambda result, addr=addr, paired_with=paired_with, fee=fee: (  # type: ignore
+                            data.setdefault(addr, []).append(
+                                V3Pool.load_static(
+                                    tokena=addr,
+                                    tokenb=paired_with,
+                                    pair_address=result,
+                                    fee=fee,
+                                )
+                            )
+                        ),
+                    ),
+                ]
+            )
+        if uniswap_v3_factory_address == Factories.Arbitrum.Camelot_V3:
+            calls_list.extend(
+                [
+                    (
+                        CamelotV3Factory(
+                            address=uniswap_v3_factory_address
+                        ).pool_by_pair(
+                            CamelotGetPoolRequest(token_a=addr, token_b=paired_with)
+                        ),
+                        lambda result, addr=addr, paired_with=paired_with: (  # type: ignore
+                            data.setdefault(addr, []).append(
+                                CamelotV3Pool.load_static(
+                                    tokena=addr, tokenb=paired_with, pair_address=result
+                                )
+                            )
+                        ),
+                    ),
+                ]
+            )
+        return calls_list
+
+    @staticmethod
+    async def find_all_pairs(
+        addresses: list[HexAddress],
+        find_pairs: list[HexAddress] = Tokens.for_network().main,
+        uniswap_v2_factory_address: HexAddress = Factories.for_network().UniswapV2,
+        uniswap_v3_factory_address: HexAddress = Factories.for_network().UniswapV3,
+        fee_tiers: list[int] = [500, 3000, 10000],
+        block_number: int | None = None,
+    ) -> dict[HexAddress, list[V2Pair | V3Pool]]:
+        data: dict[HexAddress, list[V2Pair | V3Pool]] = {}
+        calls_with_setters = []
+        for addr in addresses:
+            if addr not in data:
+                data[addr] = []
+            for paired_with in find_pairs:
+                calls_with_setters.extend(
+                    DexPairHelper.find_pair(
+                        data,
+                        addr,
+                        paired_with,
+                        fee_tiers,
+                        uniswap_v2_factory_address,
+                        uniswap_v3_factory_address,
+                    )
+                )
+        await try_execute_with_setters(
+            calls_with_setters, block_number=block_number or "latest"
+        )
+        await DexPairHelper.add_reserves_to_pairs(data, block_number=block_number)
+        return data
+
+    @staticmethod
+    async def find_all_stables_pairs(
+        find_pairs: list[HexAddress] = Tokens.for_network().main,
+        uniswap_v2_factory_address: HexAddress = Factories.for_network().UniswapV2,
+        uniswap_v3_factory_address: HexAddress = Factories.for_network().UniswapV3,
+        fee_tiers: list[int] = [500, 3000, 10000],
+        block_number: int | None = None,
+    ) -> dict[HexAddress, list[V2Pair | V3Pool]]:
+        data: dict[HexAddress, list[V2Pair | V3Pool]] = {}
+        calls_with_setters = []
+
+        unique_tuples = list(combinations(find_pairs, 2))
+
+        for t in unique_tuples:
+            calls_with_setters.extend(
+                DexPairHelper.find_pair(
+                    data,
+                    t[0],
+                    t[1],
+                    fee_tiers,
+                    uniswap_v2_factory_address,
+                    uniswap_v3_factory_address,
+                )
+            )
+        await try_execute_with_setters(
+            calls_with_setters, block_number=block_number or "latest"
+        )
+        await DexPairHelper.add_reserves_to_pairs(data, block_number=block_number)
+        return data
+
+    @staticmethod
+    async def add_reserves_to_pairs(
+        data: dict[HexAddress, list[V2Pair | V3Pool]],
+        block_number: int | None = None,
+    ):
+        calls_with_setters = []
+
+        for pairs in data.values():
+            for pair in pairs:
+                if isinstance(pair, V2Pair):
+                    calls_with_setters.append(
+                        (
+                            UniswapV2Pair(address=pair.pair_address).get_reserves(),
+                            lambda result, pair=pair: (
+                                pair.set_reserves(result[0], result[1])
+                            ),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token0.raw.decimals(),
+                            lambda result, pair=pair: (
+                                pair.token0.set_decimals(result)
+                            ),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token0.raw.symbol(),
+                            lambda result, pair=pair: (pair.token0.set_symbol(result)),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token1.raw.decimals(),
+                            lambda result, pair=pair: (
+                                pair.token1.set_decimals(result)
+                            ),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token1.raw.symbol(),
+                            lambda result, pair=pair: (pair.token1.set_symbol(result)),
+                        )
+                    )
+                elif isinstance(pair, V3Pool):
+                    calls_with_setters.append(
+                        (
+                            UniswapV3Pool(address=pair.pair_address).slot0(),
+                            lambda result, pair=pair: (pair.set_slot0(result)),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token0.raw.balance_of(
+                                OwnerRequest(owner=pair.pair_address)
+                            ),
+                            lambda result, pair=pair: (pair.set_reserve0(result)),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token1.raw.balance_of(
+                                OwnerRequest(owner=pair.pair_address)
+                            ),
+                            lambda result, pair=pair: (pair.set_reserve1(result)),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token0.raw.decimals(),
+                            lambda result, pair=pair: (
+                                pair.token0.set_decimals(result)
+                            ),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token0.raw.symbol(),
+                            lambda result, pair=pair: (pair.token0.set_symbol(result)),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token1.raw.decimals(),
+                            lambda result, pair=pair: (
+                                pair.token1.set_decimals(result)
+                            ),
+                        )
+                    )
+                    calls_with_setters.append(
+                        (
+                            pair.token1.raw.symbol(),
+                            lambda result, pair=pair: (pair.token1.set_symbol(result)),
+                        )
+                    )
+        await try_execute_with_setters(
+            calls_with_setters, block_number=block_number or "latest"
+        )

eth_protocols/helpers/multicall.py

@@ -0,0 +1,35 @@
+from eth_rpc.types import BLOCK_STRINGS
+from eth_typeshed.utils import try_execute_with_setters
+
+
+class MultiCallRequestHelper:
+    calls_with_setters: list
+    data: dict
+
+    def __init__(self):
+        self.calls_with_setters = []
+        self.data = {}
+
+    def prepare(self, address, protocol_call_func, result_handler_func):
+        self.prepare_raw(
+            address,
+            protocol_call_func,
+            lambda result: result_handler_func(self.data[address], result),
+        )
+
+    def prepare_data(self, address, init_key, init_value):
+        if address not in self.data:
+            self.data[address] = {}
+        if init_key not in self.data[address]:
+            self.data[address][init_key] = init_value
+
+    def prepare_raw(self, address, protocol_call_func, lambda_handler_func):
+        if address not in self.data:
+            self.data[address] = {}
+        self.calls_with_setters.append((protocol_call_func, lambda_handler_func))
+
+    async def call(self, block_number: int | BLOCK_STRINGS = "latest"):
+        await try_execute_with_setters(
+            self.calls_with_setters, block_number=block_number
+        )
+        return self.data

eth_protocols/helpers/price_tracker.py

@@ -0,0 +1,170 @@
+import asyncio
+from decimal import Decimal
+from typing import ClassVar, Optional
+
+from eth_protocols.logger import logger
+from eth_protocols.uniswap_v2.pair import V2Pair
+from eth_protocols.uniswap_v3.pool import V3Pool
+from eth_rpc import EventData, EventSubscriber, get_current_network
+from eth_rpc.types import Network
+from eth_typeshed.chainlink.eth_usd_feed import ChainlinkPriceOracle, ETHUSDPriceFeed
+from eth_typeshed.constants import Tokens
+from eth_typeshed.uniswap_v2 import V2SyncEvent, V2SyncEventType
+from eth_typeshed.uniswap_v3 import V3SwapEvent, V3SwapEventType
+from eth_typing import HexAddress, HexStr
+from eth_utils import to_checksum_address
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+class EthPriceProvider(BaseModel):
+    feed: ClassVar[ETHUSDPriceFeed] = ETHUSDPriceFeed(
+        address=ChainlinkPriceOracle.for_network().ETH
+    )
+    price: float | None = None
+    decimals: int = Field(default=8)
+
+    def __init__(self, block_number: int | None = None, **kwargs):
+        super().__init__(**kwargs)
+        if block_number:
+            asyncio.run(self.refresh_price(block_number=block_number))
+
+    async def refresh_price(self, block_number: int | None = None):
+        if block_number:
+            latest_round_data = (
+                await self.feed.latest_round_data().get(block_number=block_number)
+            )[1]
+        else:
+            latest_round_data = (await self.feed.latest_round_data().get())[1]
+
+        self.price = latest_round_data / 10**self.decimals
+
+    def get_eth_price(self):
+        return Decimal(self.price)
+
+
+class PriceTracker(BaseModel):
+    token_address_to_pairs: dict[HexAddress, list[V2Pair | V3Pool]] = Field(
+        default_factory=dict
+    )
+    pair_address_to_pairs: dict[HexAddress, V2Pair | V3Pool] = Field(
+        default_factory=dict
+    )
+    _eth_price_provider: EthPriceProvider = PrivateAttr(
+        default_factory=EthPriceProvider
+    )
+    network: Network = Field(default_factory=get_current_network)
+
+    @property
+    def stables(self):
+        return Tokens.for_network(self.network).stables
+
+    @property
+    def WETH(self):
+        return Tokens.for_network(self.network).WETH
+
+    @property
+    def pairs(self):
+        return [
+            pair for sublist in self.token_address_to_pairs.values() for pair in sublist
+        ]
+
+    async def get_pair_reserves(self, pair_address: HexAddress):
+        pair_address = to_checksum_address(pair_address)
+        pair = self.pair_address_to_pairs[pair_address]
+        if not pair:
+            return 0, 0
+        return await pair.reserves()
+
+    def update_pairs(self, pairs: dict[HexAddress, list[V2Pair | V3Pool]]):
+        if not pairs:
+            return
+        for k, pairs_list in pairs.items():
+            k = to_checksum_address(k)
+            tmp_pairs = []
+            for pair in pairs_list:
+                address = to_checksum_address(pair.pair_address)
+                tmp_pairs.append(pair)
+                self.pair_address_to_pairs[address] = pair
+            self.token_address_to_pairs[k] = tmp_pairs
+
+    def is_stable(self, token: HexAddress):
+        for s in self.stables:
+            if s.lower() == token.lower():
+                return True
+        return False
+
+    @staticmethod
+    def find_highest_reserve_pair(
+        token_address: HexAddress, pairs: list[V2Pair | V3Pool]
+    ):
+        highest_liq = Decimal(0)
+        ret = None
+        for pair in pairs:
+            reserve = pair.get_reserve(token_address)
+            if reserve > highest_liq:
+                ret = pair
+                highest_liq = reserve
+        return ret
+
+    def get_highest_liq_pair(self, token_address: HexAddress):
+        if not self.token_address_to_pairs:
+            raise ValueError("token address_to_pairs not set")
+        pairs_list = self.token_address_to_pairs.get(
+            to_checksum_address(token_address), []
+        )
+        return self.find_highest_reserve_pair(token_address, pairs_list)
+
+    def get_tvl_in_usd(self, pair_address):
+        if to_checksum_address(pair_address) not in self.pair_address_to_pairs:
+            logger.warning(f"not found {pair_address=}")
+            return 0
+        pair = self.pair_address_to_pairs[to_checksum_address(pair_address)]
+        return pair.get_reserve(pair.token0.address) * (
+            self.get_price_in_usd(pair.token0.address)
+        ) + pair.get_reserve(pair.token1.address) * (
+            self.get_price_in_usd(pair.token1.address)
+        )
+
+    def get_price_in_usd(
+        self, token_address: HexAddress, block_number: Optional[int] = None
+    ):
+        """
+        Recurse the token address following its deepest liquidity until we reach a token with a known price.
+        """
+        if to_checksum_address(token_address) == to_checksum_address(self.WETH):
+            return self._eth_price_provider.get_eth_price()
+        if not token_address:
+            return 0
+        if self.is_stable(token_address):
+            return 1
+        pair = self.get_highest_liq_pair(token_address)
+        if not pair:
+            # FIXME: check if any data is missing for specific pairs
+            return 0
+        price_a_to_b = pair.get_price(token_address, block_number)
+        tokenb = pair.get_other_token(token_address)
+        if self.is_stable(tokenb):  # in self.stables:
+            return price_a_to_b
+        # if not found, recurse
+        return price_a_to_b * self.get_price_in_usd(tokenb, block_number=block_number)
+
+    async def subscribe(self):
+        """
+        subscribe to events from all pairs that you're tracking price
+        if new pair added, add to pairs list and restart tracking from last hear block number
+        """
+        pair_addresses = [pair.pair_address for pair in self.pairs]
+        subscriber = EventSubscriber()
+        subscriber.add_receiver(self, [V3SwapEvent, V2SyncEvent])
+        await subscriber.listen(addresses=pair_addresses)
+
+    async def put(self, event: EventData[V3SwapEventType | V2SyncEventType]):
+        match event.event:
+            case V2SyncEventType(reserve0=reserve0, reserve1=reserve1):
+                pair = self.pair_address_to_pairs[event.tx.address]
+                pair.set_reserves(reserve0, reserve1)
+                self.pair_address_to_pairs[event.tx.address]
+            case V3SwapEventType():
+                # TODO: handle event ingest
+                #       maybe simulate reserves for V3
+                pass

eth_protocols/logger.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("eth_protocols")

eth_protocols/tokens/__init__.py

@@ -0,0 +1,5 @@
+from .erc20 import ERC20
+
+__all__ = [
+    "ERC20",
+]