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

eth_protocols/uniswap_v3/pool.py

@@ -0,0 +1,168 @@
+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.erc20 import OwnerRequest
+from eth_typeshed.multicall import multicall
+from eth_typeshed.uniswap_v3 import Slot0, UniswapV3Pool
+from eth_typing import HexAddress
+from eth_utils import to_checksum_address
+from pydantic import PrivateAttr
+
+Q192 = Decimal(2**192)
+
+
+class V3Pool(DexPair):
+    _contract: UniswapV3Pool = PrivateAttr()
+    fee: int
+
+    @classmethod
+    def load_static(
+        cls,
+        pair_address: HexAddress,
+        tokena: HexAddress,
+        tokenb: HexAddress,
+        fee: int,
+    ):
+        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,  # type: ignore
+            fee=fee,
+        )
+
+    @classmethod
+    async def load_pair(
+        cls,
+        pair_address: HexAddress,
+    ):
+        # TODO: type hints don't work with pydantic validators
+        _contract = UniswapV3Pool(address=pair_address)
+        token0, token1, fee = await multicall.execute(
+            _contract.token0(),
+            _contract.token1(),
+            _contract.fee(),
+        )
+
+        return cls(
+            token0=ERC20(address=token0),  # type: ignore
+            token1=ERC20(address=token1),  # type: ignore
+            pair_address=pair_address,  # type: ignore
+            fee=fee,
+        )
+
+    def set_slot0(self, slot0: Slot0):
+        self._slot0 = slot0
+
+    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:
+            slot0 = self._contract.slot0().get(block_number=block_number)
+        else:
+            slot0 = self._slot0
+
+        sqrt_price = slot0.sqrt_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/utils/lookup_dict.py

@@ -0,0 +1,29 @@
+from sortedcontainers import SortedDict
+
+
+class LookupDict:
+    def __init__(self):
+        self.data = SortedDict()
+
+    def add(self, key, value):
+        self.data[key] = value
+
+    def find_lte(self, key):
+        # Find the closest key that is less than or equal to the given key
+        idx = self.data.bisect_right(key) - 1
+        if idx == -1:
+            return None, None  # If all keys in the dict are greater than the given key
+        closest_key = self.data.iloc[idx]
+        return closest_key, self.data[closest_key]
+
+    def find_gte(self, key):
+        # Find the closest key that is equal to or larger than the given key
+        idx = self.data.bisect_left(key)
+        if idx == len(self.data):
+            return None, None  # If all keys in the dict are smaller than the given key
+        closest_key = self.data.iloc[idx]
+        return closest_key, self.data[closest_key]
+
+    def range_iterator(self, low_key, high_key):
+        for key in self.data.irange(low_key, high_key, inclusive=(True, True)):
+            yield key, self.data[key]

eth_protocols_py-0.1.4.dist-info/METADATA

@@ -0,0 +1,23 @@
+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: 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'
+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'
+

eth_protocols_py-0.1.4.dist-info/RECORD

@@ -0,0 +1,25 @@
+eth_protocols/__init__.py,sha256=XjIrz_SGXdHWar-Cl1ks44L8XTGtcdmPNIdl0x42rWI,262
+eth_protocols/logger.py,sha256=RVwRQqopRpd4B_I1O2XePvbnG1Q6XfQIMLcCfAivJxI,60
+eth_protocols/camelot_v3/__init__.py,sha256=Ef5CsopBI7COWMItbCpf8LBlF-48w7QYrreJ2TF9P6c,68
+eth_protocols/camelot_v3/pool.py,sha256=HR3YJC2gE9KIpBeXk5RJP7Tjo3flvjzTsD2lib7y4pw,5203
+eth_protocols/helpers/__init__.py,sha256=suGBSUplGYyutI5NLDW5d5oCrKoCJlDimUqL8UdP_G0,209
+eth_protocols/helpers/dex_pairs.py,sha256=gO3xjtN-CLe5JB5JAsr_dx2cv19VHUCYGGYK-MC6Cog,10315
+eth_protocols/helpers/multicall.py,sha256=rDwZ9IuQhzgVzchPkTLjAdtYvDqbnhs9xaoWFWKkI60,1174
+eth_protocols/helpers/price_tracker.py,sha256=s9wH9B2ruTGD-B3xVEMMvcV1-z3CWLNfTo5QARw0lmM,6455
+eth_protocols/tokens/__init__.py,sha256=P5SCiQYJ2j3Egea6Ui6aoIcUHAGzTt18GGn2MvXfVyo,53
+eth_protocols/tokens/erc20/__init__.py,sha256=yBiWw_m7JuQY22_Yq5tEXWYPuAjwWW5fPUC3E6OW_3M,6453
+eth_protocols/tokens/erc20/events.py,sha256=8pKC5ON-F7K4rlsDknFkvA0F_8ItqY-WVidwAbT6ZI0,1198
+eth_protocols/types/__init__.py,sha256=UZCacpP8BfU7VBwyLH8Q_XqamK1WZHcWdJunwJ0w27c,60
+eth_protocols/types/dex_pair.py,sha256=3OMXyBYmqpWWqJKVpVE3OeqiamCvK5F0jIlFpVMxUPQ,3957
+eth_protocols/uniswap_v2/__init__.py,sha256=Yc2TCrIM1Oof5-f-Z4JBdCTw88ZEQcCFBA410Il79Pg,160
+eth_protocols/uniswap_v2/factory.py,sha256=A_rUGKKnJv82oE14gunSnxNCxUsvaxXXdttab1peN6g,1478
+eth_protocols/uniswap_v2/pair.py,sha256=byaB6vx5r6zK_CdLLdiiAWkU5We3QFtGsfj9F-X1dZ0,5245
+eth_protocols/uniswap_v2/price.py,sha256=yhiEy-Esg2GJCbkW5WGF7vnDBNMR7o70HC2sFDDbWiM,3420
+eth_protocols/uniswap_v3/__init__.py,sha256=dSWB0Re-BIgndmTubDxkq7C2yeW_aHxzKt_1z4LqmbM,54
+eth_protocols/uniswap_v3/liquidity.py,sha256=e0meO-7Ct4RUL_uY4O7OgSAywWUnERvgwOUW8WHF0SI,63
+eth_protocols/uniswap_v3/pool.py,sha256=K2JglPT7R69x90zHYyDy0b7N9qULpQemharkgF73ZUI,5244
+eth_protocols/utils/lookup_dict.py,sha256=KpbBbbsVNvIH2xvqccyWSk2B017943exqsvgqC5gYEs,1065
+eth_protocols_py-0.1.4.dist-info/METADATA,sha256=O_AFlQCNw0LzJbhSU5yeO5QhUtXpTelvCS27Y6oax6A,776
+eth_protocols_py-0.1.4.dist-info/WHEEL,sha256=-oYQCr74JF3a37z2nRlQays_SX2MqOANoqVjBBAP2yE,91
+eth_protocols_py-0.1.4.dist-info/top_level.txt,sha256=d2sh5VgSNiq8Mx-TP_-tDYa6w5QVLghgvO8StcjUQl8,14
+eth_protocols_py-0.1.4.dist-info/RECORD,,

eth_protocols_py-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (71.0.3)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

eth_protocols_py-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+eth_protocols