eth-portfolio 0.5.8__cp311-cp311-musllinux_1_2_x86_64.whl

eth_portfolio/protocols/lending/maker.py

@@ -0,0 +1,110 @@
+from asyncio import gather
+from typing import Final
+
+from a_sync import igather
+from brownie import ZERO_ADDRESS
+from dank_mids.exceptions import Revert
+from eth_typing import HexStr
+from faster_async_lru import alru_cache
+from faster_eth_abi import encode
+from y import Contract, Network, contract_creation_block_async, get_price
+from y._decorators import stuck_coro_debugger
+from y.constants import dai
+from y.datatypes import Address, Block
+
+from eth_portfolio._utils import Decimal
+from eth_portfolio.protocols.lending._base import LendingProtocolWithLockedCollateral
+from eth_portfolio.typing import Balance, TokenBalances
+
+yfi: Final = "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e"
+dai: Contract
+_1e18: Final = Decimal(10**18)
+_1e45: Final = Decimal(10**45)
+
+
+def encode_bytes(bytestring: str) -> bytes:
+    return encode(["bytes32"], [bytestring])
+
+
+class Maker(LendingProtocolWithLockedCollateral):
+    networks = [Network.Mainnet]
+
+    def __init__(self) -> None:
+        self.proxy_registry = Contract("0x4678f0a6958e4D2Bc4F1BAF7Bc52E8F3564f3fE4")
+        self.cdp_manager = Contract("0x5ef30b9986345249bc32d8928B7ee64DE9435E39")
+        self.ilk_registry = Contract("0x5a464C28D19848f44199D003BeF5ecc87d090F87")
+        self.vat = Contract("0x35D1b3F3D7966A1DFe207aa4514C12a259A0492B")
+
+    @stuck_coro_debugger
+    async def _balances(self, address: Address, block: Block | None = None) -> TokenBalances:
+        if block is not None and block <= await contract_creation_block_async(self.ilk_registry):
+            return TokenBalances(block=block)
+
+        # `self._urn` is cached after the first call so we will await these without gather
+        urn = await self._urn(address)
+        ilks = await self.get_ilks(block)
+
+        gem_coros = igather(map(self.get_gem, map(str, ilks)))
+        ink_coros = igather(
+            self.vat.urns.coroutine(ilk, urn, block_identifier=block) for ilk in ilks
+        )
+
+        gems, ink_data = await gather(gem_coros, ink_coros)
+
+        balances: TokenBalances = TokenBalances(block=block)
+        for token, data in zip(gems, ink_data):
+            if token != ZERO_ADDRESS and (ink := data.dict()["ink"]):
+                balance = ink / _1e18
+                value = round(balance * Decimal(await get_price(token, block, sync=False)), 18)
+                balances[token] = Balance(balance, value, token=token, block=block)
+        return balances
+
+    @stuck_coro_debugger
+    async def _debt(self, address: Address, block: int | None = None) -> TokenBalances:
+        if block is not None and block <= await contract_creation_block_async(self.ilk_registry):
+            return TokenBalances(block=block)
+
+        # `self._urn` is cached after the first call so we will await these without gather
+        urn = await self._urn(address)
+        ilks = await self.get_ilks(block)
+
+        data = await igather(
+            gather(
+                self.vat.urns.coroutine(ilk, urn, block_identifier=block),
+                self.vat.ilks.coroutine(ilk, block_identifier=block),
+            )
+            for ilk in ilks
+        )
+
+        balances: TokenBalances = TokenBalances(block=block)
+        for urns, ilk_info in data:
+            art = urns.dict()["art"]
+            rate = ilk_info.dict()["rate"]
+            debt = art * rate / _1e45
+            balances[dai.address] += Balance(debt, debt, token=dai, block=block)
+        return balances
+
+    async def get_ilks(self, block: int | None) -> list[HexStr]:
+        """List all ilks (cdp keys of sorts) for MakerDAO"""
+        try:
+            return await self.ilk_registry.list.coroutine(block_identifier=block)
+        except Revert:
+            return []
+
+    @alru_cache
+    async def get_gem(self, ilk: bytes) -> str:
+        return await self.ilk_registry.gem.coroutine(ilk)
+
+    @alru_cache
+    async def _proxy(self, address: Address) -> Address:
+        return await self.proxy_registry.proxies.coroutine(address)
+
+    @alru_cache
+    async def _cdp(self, address: Address) -> Address:
+        proxy = await self._proxy(address)
+        return await self.cdp_manager.first.coroutine(proxy)
+
+    @alru_cache
+    async def _urn(self, address: Address) -> Address:
+        cdp = await self._cdp(address)
+        return await self.cdp_manager.urns.coroutine(cdp)

eth_portfolio/protocols/lending/unit.py

@@ -0,0 +1,44 @@
+from y import Contract, Network
+from y._decorators import stuck_coro_debugger
+from y.datatypes import Address, Block
+
+from eth_portfolio._decimal import Decimal
+from eth_portfolio._utils import _get_price
+from eth_portfolio.protocols.lending._base import LendingProtocolWithLockedCollateral
+from eth_portfolio.typing import Balance, TokenBalances
+
+# NOTE: This only works for YFI collateral, must extend before using for other collaterals
+yfi = "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e"
+usdp = "0x1456688345527bE1f37E9e627DA0837D6f08C925"
+
+
+class UnitXyz(LendingProtocolWithLockedCollateral):
+    networks = [Network.Mainnet]
+
+    def __init__(self) -> None:
+        self.unitVault = Contract("0xb1cff81b9305166ff1efc49a129ad2afcd7bcf19")
+        self.start_block = 11315910
+
+    @stuck_coro_debugger
+    async def _balances(self, address: Address, block: Block | None = None) -> TokenBalances:
+        balances: TokenBalances = TokenBalances(block=block)
+        if block and block < self.start_block:
+            return balances
+        bal: int = await self.unitVault.collaterals.coroutine(yfi, address, block_identifier=block)
+        if bal:
+            bal = Decimal(bal) / 10**18
+            balances[yfi] = Balance(bal, bal * await _get_price(yfi, block), token=yfi, block=block)
+        return balances
+
+    @stuck_coro_debugger
+    async def _debt(self, address: Address, block: Block | None = None) -> TokenBalances:
+        balances: TokenBalances = TokenBalances(block=block)
+        if block and block < self.start_block:
+            return balances
+        # NOTE: This only works for YFI based debt, must extend before using for other collaterals
+        if debt := await self.unitVault.getTotalDebt.coroutine(
+            yfi, address, block_identifier=block
+        ):
+            debt = Decimal(debt) / 10**18
+            balances[usdp] = Balance(debt, debt, token=usdp, block=block)
+        return balances

eth_portfolio/protocols/liquity.py

@@ -0,0 +1,17 @@
+from y import ERC20, Network
+
+from eth_portfolio.protocols._base import SingleTokenStakingPoolABC
+
+
+class LqtyStakingPool(SingleTokenStakingPoolABC):
+    networks = [Network.Mainnet]
+    contract_address = "0x4f9Fbb3f1E99B56e0Fe2892e623Ed36A76Fc605d"
+    balance_method_name = "stakes"
+    token = ERC20("0x6DEA81C8171D0bA574754EF6F8b412F2Ed88c54D")  # LQTY
+
+
+class LiquityStabilityPool(SingleTokenStakingPoolABC):
+    networks = [Network.Mainnet]
+    contract_address = "0x66017D22b0f8556afDd19FC67041899Eb65a21bb"
+    balance_method_name = "getCompoundedLUSDDeposit"
+    token = ERC20("0x5f98805A4E8be255a32880FDeC7F6728C6568bA0")  # LUSD

eth_portfolio/structs/__init__.py

@@ -0,0 +1,43 @@
+"""
+This module provides the primary union type and specific ledger entry types used in the `eth_portfolio` package.
+
+The `__all__` list defines the public API for this module, which includes the main union type `LedgerEntry` and its specific types: `Transaction`, `InternalTransfer`, `TokenTransfer`, and `TransactionRLP`.
+
+Examples:
+    Importing the main union type and specific ledger entry types:
+
+    >>> from eth_portfolio.structs import LedgerEntry, Transaction, InternalTransfer, TokenTransfer, TransactionRLP
+
+    Using the `LedgerEntry` union type to annotate a variable that can hold any ledger entry type:
+
+    >>> entry: LedgerEntry = Transaction(...)
+    >>> entry = InternalTransfer(...)
+    >>> entry = TokenTransfer(...)
+    >>> entry = TransactionRLP(...)
+
+See Also:
+    - :class:`~eth_portfolio.structs.structs.LedgerEntry`
+    - :class:`~eth_portfolio.structs.structs.Transaction`
+    - :class:`~eth_portfolio.structs.structs.InternalTransfer`
+    - :class:`~eth_portfolio.structs.structs.TokenTransfer`
+    - :class:`~eth_portfolio.structs.structs.TransactionRLP`
+"""
+
+from eth_portfolio.structs.structs import (
+    InternalTransfer,
+    LedgerEntry,
+    TokenTransfer,
+    Transaction,
+    TransactionRLP,
+)
+
+__all__ = [
+    # main union type
+    "LedgerEntry",
+    # LedgerEntry types
+    "Transaction",
+    "InternalTransfer",
+    "TokenTransfer",
+    # TODO figure out how to get rid of this
+    "TransactionRLP",
+]

eth_portfolio/structs/modified.py

@@ -0,0 +1,69 @@
+from typing import Union
+
+from evmspec.structs.trace import call, create, reward, suicide
+
+
+class CallTrace(
+    call.Trace,
+    frozen=True,
+    kw_only=True,
+    array_like=True,
+    forbid_unknown_fields=True,
+    omit_defaults=True,
+    repr_omit_defaults=True,
+):  # type: ignore [call-arg]
+    """
+    It works just like a :class:`evmspec.trace.call.Trace` but it encodes to a tuple instead of a dict to save space since keys are known.
+    """
+
+
+class CreateTrace(
+    create.Trace,
+    frozen=True,
+    kw_only=True,
+    array_like=True,
+    forbid_unknown_fields=True,
+    omit_defaults=True,
+    repr_omit_defaults=True,
+):  # type: ignore [call-arg]
+    """
+    It works just like a :class:`evmspec.trace.create.Trace` but it encodes to a tuple instead of a dict to save space since keys are known.
+    """
+
+
+class RewardTrace(
+    reward.Trace,
+    frozen=True,
+    kw_only=True,
+    array_like=True,
+    forbid_unknown_fields=True,
+    omit_defaults=True,
+    repr_omit_defaults=True,
+):  # type: ignore [call-arg]
+    """
+    It works just like a :class:`evmspec.trace.reward.Trace` but it encodes to a tuple instead of a dict to save space since keys are known.
+    """
+
+
+class SuicideTrace(
+    suicide.Trace,
+    frozen=True,
+    kw_only=True,
+    array_like=True,
+    forbid_unknown_fields=True,
+    omit_defaults=True,
+    repr_omit_defaults=True,
+):  # type: ignore [call-arg]
+    """
+    It works just like a :class:`evmspec.trace.suicide.Trace` but it encodes to a tuple instead of a dict to save space since keys are known.
+    """
+
+
+_modified_trace_type_map = {
+    call.Trace: CallTrace,
+    create.Trace: CreateTrace,
+    reward.Trace: RewardTrace,
+    suicide.Trace: SuicideTrace,
+}
+
+ModifiedTrace = Union[CallTrace, CreateTrace, RewardTrace, SuicideTrace]