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

eth_protocols/tokens/erc20/__init__.py

@@ -0,0 +1,198 @@
+from copy import deepcopy
+from typing import Annotated, ClassVar, Generic, cast
+
+from eth_rpc import get_current_network
+from eth_rpc.types import BLOCK_STRINGS, MaybeAwaitable, Network, primitives
+from eth_typeshed import ERC20 as ERC20Contract
+from eth_typeshed.erc20 import OwnerRequest, OwnerSpenderRequest
+from eth_typing import ChecksumAddress, HexAddress
+from eth_utils import to_checksum_address
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, WrapValidator
+from typing_extensions import TypeVar
+
+from .events import TransferEvents
+
+NetworkType = TypeVar("NetworkType", bound=Network | None, default=None)
+
+
+class ERC20(BaseModel, Generic[NetworkType]):
+    model_config = ConfigDict(frozen=True)
+    _network: ClassVar[Network | None] = None
+
+    tokens: ClassVar[dict[tuple[Network, ChecksumAddress], "ERC20"]] = {}
+    events: TransferEvents = Field(default_factory=TransferEvents)
+
+    address: Annotated[
+        ChecksumAddress, WrapValidator(lambda addr, y, z: to_checksum_address(addr))
+    ]
+    network: Network = Field(default_factory=get_current_network)
+
+    _contract: ERC20Contract = PrivateAttr()
+    _decimals: primitives.uint256 | None = PrivateAttr(None)
+    _name: primitives.string | None = PrivateAttr(None)
+    _symbol: primitives.string | None = PrivateAttr(None)
+
+    def __class_getitem__(cls, network: Network):
+        cls._network = network
+        return cls
+
+    @property
+    def sync(self) -> "ERC20Sync":
+        obj = deepcopy(self)
+        obj.__class__ = ERC20Sync
+        obj = cast(ERC20Sync, obj)
+        return obj
+
+    @property
+    def raw(self) -> ERC20Contract:
+        return self._contract
+
+    @classmethod
+    def get_network(cls, network: Network | None) -> Network:
+        return network or cls._network or get_current_network()
+
+    @classmethod
+    def load(cls, address: HexAddress, network: Network | None = None):
+        checksum_address = to_checksum_address(address)
+
+        network = cls.get_network(network)
+        key = (network, checksum_address)
+        if key not in cls.tokens:
+            cls.tokens[key] = cls(address=checksum_address, network=network)
+
+        # unset the network on the class instance
+        cls._network = None
+        return cls.tokens[key]
+
+    def model_post_init(self, __context):
+        self._contract = ERC20Contract(address=self.address)
+        self.events.set_address(self.address)
+
+    def set_decimals(self, decimals: int):
+        if not decimals:
+            return
+        self._decimals = decimals
+
+    def set_symbol(self, symbol: int):
+        if not symbol:
+            return
+        self._symbol = symbol
+
+    async def decimals(self) -> primitives.uint256:
+        if not self._decimals:
+            self._decimals = await self._contract.decimals().get()
+        assert self._decimals
+        return self._decimals
+
+    async def name(self) -> primitives.string:
+        if not self._name:
+            self._name = await self._contract.name().get()
+        assert self._name
+        return self._name
+
+    async def symbol(self) -> primitives.string:
+        if not self._symbol:
+            self._symbol = await self._contract.symbol().get()
+        assert self._symbol
+        return self._symbol
+
+    def total_supply(
+        self,
+        block_number: int | BLOCK_STRINGS = "latest",
+        sync: bool = False,
+    ) -> MaybeAwaitable[primitives.uint256]:
+        return self._contract.total_supply().get(
+            block_number=block_number,
+            sync=sync,
+        )
+
+    def balance_of(
+        self,
+        owner: HexAddress,
+        block_number: int | BLOCK_STRINGS = "latest",
+        sync: bool = False,
+    ) -> MaybeAwaitable[int]:
+        return self._contract.balance_of(OwnerRequest(owner=owner)).get(
+            block_number=block_number,
+            sync=sync,
+        )
+
+    def allowance(
+        self,
+        owner: HexAddress,
+        spender: HexAddress,
+        block_number: int | BLOCK_STRINGS = "latest",
+        sync: bool = False,
+    ) -> MaybeAwaitable[int]:
+        return self._contract.allowance(
+            OwnerSpenderRequest(owner=owner, spender=spender)
+        ).get(block_number=block_number, sync=sync)
+
+    def __repr__(self):
+        return f"<ERC20 address={self.address}>"
+
+    def __lt__(self, other: "ERC20" | HexAddress) -> bool:
+        if isinstance(other, ERC20):
+            return self.address < other.address
+        return self.address < other
+
+    def __gt__(self, other: "ERC20" | HexAddress) -> bool:
+        if isinstance(other, ERC20):
+            return self.address > other.address
+        return self.address > other
+
+
+class ERC20Sync(ERC20):
+    def decimals(self) -> int:  # type: ignore
+        if not self._decimals:
+            self._decimals = self._contract.decimals().get(sync=True)
+        assert self._decimals
+        return self._decimals
+
+    def name(self) -> str:  # type: ignore
+        if not self._name:
+            self._name = self._contract.name().get(sync=True)
+        assert self._name
+        return self._name
+
+    def symbol(self) -> str:  # type: ignore
+        if not self._symbol:
+            self._symbol = self._contract.symbol().get(sync=True)
+        assert self._symbol
+        return self._symbol
+
+    def total_supply(self, block_number: int | BLOCK_STRINGS = "latest") -> int:  # type: ignore
+        return self._contract.total_supply().get(block_number=block_number, sync=True)
+
+    def balance_of(  # type: ignore
+        self,
+        owner: HexAddress,
+        block_number: int | BLOCK_STRINGS = "latest",
+    ) -> int:
+        return self._contract.balance_of(OwnerRequest(owner=owner)).get(
+            block_number=block_number,
+            sync=True,
+        )
+
+    def allowance(  # type: ignore
+        self,
+        owner: HexAddress,
+        spender: HexAddress,
+        block_number: int | BLOCK_STRINGS = "latest",
+    ) -> int:
+        return self._contract.allowance(
+            OwnerSpenderRequest(owner=owner, spender=spender)
+        ).get(
+            block_number=block_number,
+            sync=True,
+        )
+
+    def __lt__(self, other: "ERC20" | HexAddress) -> bool:
+        if isinstance(other, ERC20):
+            return self.address < other.address
+        return self.address < other
+
+    def __gt__(self, other: "ERC20" | HexAddress) -> bool:
+        if isinstance(other, ERC20):
+            return self.address > other.address
+        return self.address > other

eth_protocols/tokens/erc20/events.py

@@ -0,0 +1,37 @@
+from collections.abc import AsyncIterator
+
+from eth_rpc import EventData
+from eth_rpc.constants import ADDRESS_ZERO
+from eth_rpc.utils import address_to_topic
+from eth_typeshed.erc20 import TransferEvent, TransferEventType
+from eth_typing import HexAddress
+from pydantic import BaseModel
+
+
+class TransferEvents(BaseModel):
+    address: HexAddress | None = None
+
+    def set_address(self, address: HexAddress):
+        self.address = address
+
+    def mints(self) -> AsyncIterator[EventData[TransferEventType]]:
+        return self.transfers(
+            sender=ADDRESS_ZERO,
+        )
+
+    def burns(self) -> AsyncIterator[EventData[TransferEventType]]:
+        return self.transfers(
+            recipient=ADDRESS_ZERO,
+        )
+
+    def transfers(
+        self,
+        sender: HexAddress | None = None,
+        recipient: HexAddress | None = None,
+        step_size: int | None = None,
+    ) -> AsyncIterator[EventData[TransferEventType]]:
+        return TransferEvent.set_filter(
+            addresses=[self.address],
+            topic1=address_to_topic(sender) if sender else None,
+            topic2=address_to_topic(recipient) if recipient else None,
+        ).backfill(step_size=step_size)

eth_protocols/types/__init__.py

@@ -0,0 +1,5 @@
+from .dex_pair import DexPair
+
+__all__ = [
+    "DexPair",
+]

eth_protocols/types/dex_pair.py

@@ -0,0 +1,123 @@
+from abc import ABC, abstractmethod
+from decimal import Decimal
+from functools import cached_property
+from typing import Annotated, Any, ClassVar, Generic, Optional, cast
+
+from eth_protocols.tokens import ERC20
+from eth_rpc import get_current_network
+from eth_rpc.types import BLOCK_STRINGS, MaybeAwaitable, Network
+from eth_typeshed._base import ProtocolBase
+from eth_typing import ChecksumAddress, HexAddress
+from eth_utils import to_checksum_address
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    PrivateAttr,
+    ValidationInfo,
+    ValidatorFunctionWrapHandler,
+    computed_field,
+)
+from pydantic.functional_validators import WrapValidator
+from typing_extensions import Self, TypeVar
+
+NetworkType = TypeVar("NetworkType", bound=Network | None, default=None)
+
+
+def load_token(
+    v: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
+) -> ERC20:
+    if isinstance(v, ERC20):
+        return v
+    return ERC20.load(address=v)
+
+
+class DexPair(ABC, BaseModel, Generic[NetworkType]):
+    model_config = ConfigDict(frozen=True)
+    _network: ClassVar[Network | None] = None
+    pairs: ClassVar[dict[tuple[Network, ChecksumAddress], "DexPair"]] = {}
+
+    pair_address: Annotated[
+        ChecksumAddress, WrapValidator(lambda addr, y, z: to_checksum_address(addr))
+    ]
+    token0: Annotated[ERC20, WrapValidator(load_token)]
+    token1: Annotated[ERC20, WrapValidator(load_token)]
+    network: Network = Field(default_factory=get_current_network)
+
+    _contract: ProtocolBase
+    _reserve0: Optional[int] = PrivateAttr(None)
+    _reserve1: Optional[int] = PrivateAttr(None)
+
+    def __class_getitem__(cls, network: Network):
+        cls._network = network
+        return cls
+
+    @classmethod
+    def load(cls, pair: HexAddress | Self, **kwargs):
+        if isinstance(pair, DexPair):
+            return pair
+        pair = cast(HexAddress, pair)
+        checksum_address = to_checksum_address(pair)
+        network = cls._network or get_current_network()
+        key = (network, checksum_address)
+        if key not in cls.pairs:
+            cls.pairs[key] = cls[network].load_pair(pair_address=checksum_address)  # type: ignore
+        # unset the network on the class instance
+        cls._network = None
+        return cls.pairs[key]
+
+    @classmethod
+    def load_pair(
+        cls,
+        pair_address: HexAddress,
+    ): ...
+
+    @property
+    def address(self) -> ChecksumAddress:
+        return self.pair_address
+
+    async def reserves(self):
+        return Decimal(self._reserve0 / 10**self.decimals0), Decimal(
+            self._reserve1 / 10**self.decimals1
+        )
+
+    def get_reserve(self, token: HexAddress) -> Decimal:
+        token = to_checksum_address(token)
+        if self._reserve0 is None and self._reserve1 is None:
+            raise ValueError("Must set reserves first")
+        if token == self.token0.address:
+            return Decimal(self._reserve0 / 10**self.decimals0)
+        if token == self.token1.address:
+            return Decimal(self._reserve1 / 10**self.decimals1)
+        return Decimal(0)
+
+    def set_reserves(self, reserve0: int, reserve1: int):
+        self._reserve0 = reserve0
+        self._reserve1 = reserve1
+
+    @abstractmethod
+    async def get_price(
+        self, token: HexAddress, block_number: Optional[int | BLOCK_STRINGS] = None
+    ) -> Decimal: ...
+
+    @abstractmethod
+    def get_reserves(
+        self, block_number: int | BLOCK_STRINGS = "latest", sync: bool = False
+    ) -> MaybeAwaitable[tuple[int, int]]: ...
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def flipped(self) -> bool:
+        return self.token0.address < self.token1.address
+
+    @cached_property
+    def decimals0(self):
+        return self.token0.sync.decimals()
+
+    @cached_property
+    def decimals1(self):
+        return self.token1.sync.decimals()
+
+    async def load_decimals(self):
+        await self.token0.decimals()
+        await self.token1.decimals()

eth_protocols/uniswap_v2/__init__.py

@@ -0,0 +1,8 @@
+from .factory import V2Factory
+from .pair import V2Pair, get_uniswap_v2_pair_addr
+
+__all__ = [
+    "V2Factory",
+    "V2Pair",
+    "get_uniswap_v2_pair_addr",
+]

eth_protocols/uniswap_v2/factory.py

@@ -0,0 +1,46 @@
+from typing import ClassVar
+
+from eth_rpc import get_current_network
+from eth_rpc.types import Network
+from eth_typeshed.uniswap_v2 import GetPairRequest, UniswapV2Factory
+from eth_typing import ChecksumAddress, HexAddress
+from eth_utils import to_checksum_address
+from pydantic import BaseModel, Field, PrivateAttr
+
+from .pair import V2Pair
+
+
+class V2Factory(BaseModel):
+    pairs: ClassVar[
+        dict[tuple[Network, ChecksumAddress, ChecksumAddress], "ChecksumAddress"]
+    ] = Field({})
+    _network: ClassVar[Network | None] = None
+
+    _contract: UniswapV2Factory = PrivateAttr()
+    address: HexAddress
+
+    def __class_getitem__(cls, network: Network):
+        cls._network = network
+
+    def model_post_init(self, __context):
+        self._contract = UniswapV2Factory(address=self.address)
+
+    @classmethod
+    async def load_pair(cls, token0: HexAddress, token1: HexAddress) -> "V2Pair":
+        network: Network = cls._network or get_current_network()
+        token0 = to_checksum_address(token0)
+        token1 = to_checksum_address(token1)
+        key = (network, token0, token1)
+
+        if key not in cls.pairs:
+            pair_address: HexAddress = await cls._contract.get_pair(
+                GetPairRequest(
+                    token_a=token0,
+                    token_b=token1,
+                )
+            )
+            cls.pairs[key] = to_checksum_address(pair_address)
+
+        return V2Pair.load(
+            pair_address=cls.pairs[key],
+        )

eth_protocols/uniswap_v2/pair.py

@@ -0,0 +1,146 @@
+import asyncio
+from decimal import Decimal
+from typing import ClassVar, Optional
+
+from eth_hash.auto import keccak as keccak_256
+from eth_protocols.tokens import ERC20
+from eth_protocols.types import DexPair
+from eth_rpc import Contract, get_current_network
+from eth_rpc.types import BLOCK_STRINGS, MaybeAwaitable, Network
+from eth_typeshed.multicall import multicall
+from eth_typeshed.uniswap_v2 import UniswapV2Pair
+from eth_typing import HexAddress, HexStr
+from eth_utils import to_checksum_address
+from pydantic import PrivateAttr
+
+
+class V2Pair(DexPair):
+    _network: ClassVar[Network | None] = None
+    _contract: UniswapV2Pair = PrivateAttr()
+
+    def __class_getitem__(cls, network: Network):
+        cls._network = network
+
+    @classmethod
+    def load_static(
+        cls,
+        pair_address: HexAddress,
+        tokena: HexAddress,
+        tokenb: HexAddress,
+    ):
+
+        token0, token1 = (
+            (tokena, tokenb) if tokena.lower() < tokenb.lower() else (tokenb, tokena)
+        )
+        network = cls._network or get_current_network()
+        return V2Pair(
+            pair_address=pair_address,  # type: ignore
+            token0=ERC20.load(token0, network=network),
+            token1=ERC20.load(token1, network=network),
+        )
+
+    @classmethod
+    async def load_pair(
+        cls,
+        pair_address: HexAddress,
+    ):
+        _contract = UniswapV2Pair(address=pair_address)
+        token0, token1 = await multicall.execute(
+            _contract.token0(),
+            _contract.token1(),
+        )
+        network = cls._network or get_current_network()
+        return V2Pair(
+            pair_address=pair_address,  # type: ignore
+            token0=ERC20.load(token0, network=network),
+            token1=ERC20.load(token1, network=network),
+        )
+
+    def model_post_init(self, __context):
+        self._contract = UniswapV2Pair(address=self.pair_address)
+
+    def get_reserves(
+        self, block_number: int | BLOCK_STRINGS = "latest", sync: bool = False
+    ) -> MaybeAwaitable[tuple[int, int]]:
+        if sync:
+            reserve0, reserve1, _ = self._contract.get_reserves().get(
+                block_number=block_number, sync=sync
+            )
+            self.set_reserves(reserve0, reserve1)
+            return reserve0, reserve1
+
+        # create an async function that loads the reserves
+        async def get_reserves() -> tuple[int, int]:
+            reserve0, reserve1, _ = await self._contract.get_reserves().get(
+                block_number=block_number
+            )
+            self.set_reserves(reserve0, reserve1)
+            return reserve0, reserve1
+
+        return get_reserves
+
+    def get_price(
+        self, token: HexAddress, block_number: Optional[int | BLOCK_STRINGS] = None
+    ) -> Decimal:
+        token = to_checksum_address(token)
+        assert (
+            token.lower() == self.token0.address.lower()
+            or token.lower() == self.token1.address.lower()
+        ), "invalid token"
+        token_a, token_b = (
+            (self.token0, self.token1)
+            if token.lower() == self.token0.address.lower()
+            else (self.token1, self.token0)
+        )
+
+        if block_number:
+            reserve0, reserve1, _ = self._contract.get_reserves().get(
+                block_number=block_number
+            )
+            if token == self.token0.address:
+                reserve_a = Decimal(reserve0 / 10**self.decimals0)
+                reserve_b = Decimal(reserve1 / 10**self.decimals1)
+                return Decimal(reserve_b / reserve_a)
+            if token == self.token1.address:
+                reserve_a = Decimal(reserve1 / 10**self.decimals1)
+                reserve_b = Decimal(reserve0 / 10**self.decimals0)
+                return Decimal(reserve_b / reserve_a)
+            return Decimal("0")
+
+        reserve_a = self.get_reserve(token_a.address)
+        reserve_b = self.get_reserve(token_b.address)
+
+        return Decimal(reserve_b / reserve_a)
+
+    def get_other_token(self, token: HexAddress) -> HexAddress:
+        token = to_checksum_address(token)
+        if token == self.token0.address:
+            return self.token1.address
+        if token == self.token1.address:
+            return self.token0.address
+        raise ValueError(
+            f"{token=} cannot be found {self.token0.address=} {self.token1.address=}"
+        )
+
+    async def load_decimals(self):
+        await asyncio.gather(
+            self.token0.decimals(),
+            self.token1.decimals(),
+        )
+
+
+def get_uniswap_v2_pair_addr(token_a: HexAddress, token_b: HexAddress) -> HexAddress:
+    # get factory address
+    factory_address = HexAddress(HexStr("0x5C69BEE701EF814A2B6A3EDD4B1652CB9CC5AA6F"))
+    factory_contract = Contract(address=factory_address)
+
+    # sort tokens and create salt
+    token_a, token_b = sorted([token_a, token_b])
+    salt = keccak_256(bytes.fromhex(token_a[2:]) + bytes.fromhex(token_b[2:]))
+
+    # hard coded init code because it's deployed via a contract.  this would require a trace to do it generically
+    keccak_init_code = bytes.fromhex(
+        "96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f"
+    )
+
+    return to_checksum_address(factory_contract.create2(salt, keccak_init_code))

eth_protocols/uniswap_v2/price.py

@@ -0,0 +1,104 @@
+from decimal import Decimal
+
+from eth_rpc import EventData, EventSubscriber
+from eth_typeshed.constants import Factories
+from eth_typeshed.uniswap_v2 import V2SyncEvent, V2SyncEventType
+from eth_typing import HexAddress
+from pydantic import BaseModel, Field, PrivateAttr
+
+from .factory import V2Factory
+from .pair import V2Pair
+
+
+class TerminateError(Exception):
+    """This is a custom error used to interrupt the subscription"""
+
+
+class UniswapV2PriceSubscriber(BaseModel):
+    """
+    from eth_typeshed.constants import Tokens, Routers
+    from eth_rpc import PrivateKeyWallet
+
+    class MyLimitOrder(UniswapV2PriceSubscriber):
+        limit_price: float
+        router: UniswapV2Router
+        wallet: PrivateKeyWallet
+
+        async def handle_price_update(self, price: Decimal, event: EventData[V2SyncEventType]):
+            if price < limit_price:
+                await self.router.swap(
+                    mint_amount_out=min_amount_out,
+                    path=[Tokens.Ethereum.WETH, Tokens.Ethereum.USDC],
+                    recipient=self.wallet.address,
+                ).execute(self.wallet)
+                self.terminate()
+
+    async def amain():
+        limit_order = MyLimitOrder(
+            wallet=PrivateKeyWallet(),
+        )
+        pair = V2Factory.load_pair(token0=Tokens.Ethereum.USDC, token1=Tokens.Ethereum.WETH)
+        limit_order.add_pair(pair)
+        await limit_order.subscribe()
+    """
+
+    pairs: dict[HexAddress, V2Pair] = Field(default_factory=dict)
+    factory_address: HexAddress = Field(Factories.Ethereum.UniswapV2)
+
+    _factory: V2Factory = PrivateAttr()
+    _prepared: bool = PrivateAttr(False)
+    _subscriber: EventSubscriber = PrivateAttr(
+        default_factory=lambda: EventSubscriber()
+    )
+
+    def model_post_init(self, __context):
+        self._factory = V2Factory(self.factory_address)
+        self._subscriber.add_receiver(self, [V2SyncEvent])
+
+    @property
+    def factory(self):
+        return self._factory
+
+    @property
+    def subscriber(self):
+        return self._subscriber
+
+    async def add_pair(
+        self,
+        pair: HexAddress | V2Pair,
+    ):
+        pair = V2Pair.load(pair)
+        self.pairs[pair.address.lower()] = pair  # type: ignore
+
+    async def subscribe(self):
+        try:
+            await self.subscriber.listen(
+                addresses=[pair_address for pair_address in self.pairs.keys()]
+            )
+        except TerminateError:
+            # This is a simple way to exit out of the subscribe loop
+            return
+
+    async def put(self, event_data: EventData[V2SyncEventType]):
+        await self.handle_price_update(
+            self.get_price(event_data.event, event_data.log.address),
+            event_data,
+        )
+
+    def get_price(self, event: V2SyncEventType, address: HexAddress):
+        pair = self.pairs[address.lower()]  # type: ignore
+        token0_reserves = event.reserve0 / 10 ** pair.token0.sync.decimals()
+        token1_reserves = event.reserve1 / 10 ** pair.token1.sync.decimals()
+
+        if pair.flipped:
+            return token1_reserves / token0_reserves
+        return token0_reserves / token1_reserves
+
+    async def handle_price_update(
+        self, price: Decimal, event: EventData[V2SyncEventType]
+    ):
+        """Define an action based on a price"""
+
+    def terminate(self):
+        """Ends the subscription by catching a custom error"""
+        raise TerminateError()

eth_protocols/uniswap_v3/__init__.py

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

eth_protocols/uniswap_v3/liquidity.py

@@ -0,0 +1,3 @@
+class UniswapV3Liquidity:
+    def __init__(self):
+        pass