eth-protocols-py 0.1.4__tar.gz

eth_protocols_py-0.1.4/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: eth-protocols-py
+Version: 0.1.4
+Requires-Python: >=3.10
+Requires-Dist: eth_rpc_py
+Requires-Dist: eth_typeshed_py
+Requires-Dist: sortedcontainers
+Requires-Dist: eth_hash
+Provides-Extra: lint
+Requires-Dist: mypy; extra == "lint"
+Requires-Dist: ruff; extra == "lint"
+Provides-Extra: test
+Requires-Dist: pytest==7.4.1; extra == "test"
+Requires-Dist: pytest-cov==4.1.0; extra == "test"
+Requires-Dist: coverage[toml]==7.3.1; extra == "test"
+Provides-Extra: build
+Requires-Dist: build[virtualenv]==1.0.3; extra == "build"
+Provides-Extra: dev
+Requires-Dist: tox; extra == "dev"
+Requires-Dist: eth-protocols-py[lint]; extra == "dev"
+Requires-Dist: eth-protocols-py[test]; extra == "dev"
+Requires-Dist: eth-protocols-py[build]; extra == "dev"

eth_protocols_py-0.1.4/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68", "setuptools_scm[toml]>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eth-protocols-py"
+requires-python = ">=3.10"
+dynamic = ["version"]
+dependencies = [
+    "eth_rpc_py",
+    "eth_typeshed_py",
+    "sortedcontainers",
+    "eth_hash"
+]
+
+# Enables the usage of setuptools_scm
+[tool.setuptools_scm]
+root = "../../"
+
+[project.optional-dependencies]
+lint = [
+    "mypy",
+    "ruff",
+]
+test = [
+    "pytest==7.4.1",
+    "pytest-cov==4.1.0",
+    "coverage[toml]==7.3.1",
+]
+build = [
+    "build[virtualenv]==1.0.3",
+]
+dev = [
+    "tox",
+    "eth-protocols-py[lint]",
+    "eth-protocols-py[test]",
+    "eth-protocols-py[build]",
+]

eth_protocols_py-0.1.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

eth_protocols_py-0.1.4/setup.py

@@ -0,0 +1,13 @@
+import os
+
+from setuptools import find_packages, setup
+
+
+def get_version():
+    return os.getenv("PACKAGE_VERSION", "0.0.0")
+
+
+setup(
+    name="eth-protocols-py",
+    version=get_version(),
+)

eth_protocols_py-0.1.4/src/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_py-0.1.4/src/eth_protocols/camelot_v3/__init__.py

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

eth_protocols_py-0.1.4/src/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_py-0.1.4/src/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_py-0.1.4/src/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_py-0.1.4/src/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