eth-portfolio-temp 0.0.28.dev0__cp310-cp310-win_amd64.whl → 0.2.17__cp310-cp310-win_amd64.whl

eth_portfolio/buckets.py

@@ -1,21 +1,26 @@
 import logging
-from typing import Optional, Set
+from typing import Any, Final, Optional, Set
 
 from a_sync import igather
-from async_lru import alru_cache
-from brownie import chain
-from y.constants import STABLECOINS, WRAPPED_GAS_COIN
+from eth_typing import ChecksumAddress
+from faster_async_lru import alru_cache
+from y.constants import CHAINID, STABLECOINS, WRAPPED_GAS_COIN
+from y.convert import to_address
 from y.datatypes import Address, AnyAddressType
+from y.exceptions import ContractNotVerified
 from y.prices.lending.aave import aave
 from y.prices.lending.compound import CToken, compound
 from y.prices.stable_swap.curve import curve
 from y.prices.yearn import YearnInspiredVault, is_yearn_vault
 
 from eth_portfolio.constants import BTC_LIKE, ETH_LIKE, INTL_STABLECOINS
+from eth_portfolio._stableish import STABLEISH_COINS
 
-logger = logging.getLogger(__name__)
+logger: Final = logging.getLogger(__name__)
+log_debug: Final = logger.debug
 
-OTHER_LONG_TERM_ASSETS: Set[Address] = {}.get(chain.id, set())
+SORT_AS_STABLES: Final = STABLECOINS.keys() | STABLEISH_COINS[CHAINID]
+OTHER_LONG_TERM_ASSETS: Final[Set[ChecksumAddress]] = {}.get(CHAINID, set())  # type: ignore [call-overload]
 
 
 async def get_token_bucket(token: AnyAddressType) -> str:
@@ -53,27 +58,25 @@ async def get_token_bucket(token: AnyAddressType) -> str:
         - :func:`_unwrap_token`
         - :func:`_is_stable`
     """
-    token = str(token)
+    token_address = to_address(token)
     try:
-        token = str(await _unwrap_token(token))
-    except ValueError as e:
-        if str(e).startswith("Source for") and str(e).endswith("has not been verified"):
-            return "Other short term assets"
-        raise
+        token_address = await _unwrap_token(token_address)
+    except ContractNotVerified as e:
+        return "Other short term assets"
 
-    if _is_stable(token):
+    if _is_stable(token_address):
         return "Cash & cash equivalents"
-    if token in ETH_LIKE:
+    if token_address in ETH_LIKE:
         return "ETH"
-    if token in BTC_LIKE:
+    if token_address in BTC_LIKE:
         return "BTC"
-    if token in OTHER_LONG_TERM_ASSETS:
+    if token_address in OTHER_LONG_TERM_ASSETS:
         return "Other long term assets"
     return "Other short term assets"
 
 
 @alru_cache(maxsize=None)
-async def _unwrap_token(token) -> str:
+async def _unwrap_token(token: Any) -> ChecksumAddress:
     """
     Recursively unwrap a token to its underlying asset.
 
@@ -101,23 +104,31 @@ async def _unwrap_token(token) -> str:
         - :class:`y.prices.lending.aave`
         - :class:`y.prices.lending.compound.CToken`
     """
+    log_debug("unwrapping %s", token)
     if str(token) in {"ETH", "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"}:
+        log_debug("returning eee address")
         return token
 
     if await is_yearn_vault(token, sync=False):
         underlying = await YearnInspiredVault(token, asynchronous=True).underlying
+        log_debug("underlying: %s", underlying)
         return await _unwrap_token(underlying)
     if curve and (pool := await curve.get_pool(token)):
         pool_tokens = set(await igather(map(_unwrap_token, await pool.coins)))
+        log_debug("pool_tokens: %s", pool_tokens)
         if pool_bucket := _pool_bucket(pool_tokens):
+            log_debug("returning pool bucket: %s", pool_bucket)
             return pool_bucket  # type: ignore
     if aave and await aave.is_atoken(token):
+        log_debug("atoken")
         return str(await aave.underlying(token))
     if compound and await compound.is_compound_market(token):
+        log_debug("unwrapping ctoken %s", token)
         try:
             return str(await CToken(token, asynchronous=True).underlying)
         except AttributeError:
             return WRAPPED_GAS_COIN
+    log_debug("returning: %s", token)
     return token
 
 
@@ -148,28 +159,29 @@ def _pool_bucket(pool_tokens: set) -> Optional[str]:
         - :data:`STABLECOINS`
         - :data:`INTL_STABLECOINS`
     """
-    logger.debug("Pool tokens: %s", pool_tokens)
+    log_debug("Pool tokens: %s", pool_tokens)
     if pool_tokens < BTC_LIKE:
         return list(BTC_LIKE)[0]
     if pool_tokens < ETH_LIKE:
         return list(ETH_LIKE)[0]
-    if pool_tokens < STABLECOINS.keys():
-        return list(STABLECOINS.keys())[0]
+    if pool_tokens < SORT_AS_STABLES:
+        return list(SORT_AS_STABLES)[0]
     return list(INTL_STABLECOINS)[0] if pool_tokens < INTL_STABLECOINS else None
 
 
-def _is_stable(token: Address) -> bool:
+def _is_stable(token: ChecksumAddress) -> bool:
     """
-    Check if a token is a stablecoin.
+    Check if a token is a stablecoin or stable-ish coin.
 
-    This function checks if a given token is present in the :data:`STABLECOINS` or
-    :data:`INTL_STABLECOINS` sets, indicating that it is a stablecoin.
+    This function checks if a given token is present in the :data:`STABLECOINS`,
+    :data:`INTL_STABLECOINS`, or :data:`STABLEISH_COINS` sets, indicating that it is
+    a stablecoin or considered stable by the wider market.
 
     Args:
         token: The address of the token to check.
 
     Example:
-        Check if a token is a stablecoin:
+        Check if a token is a stablecoin or stable-ish coin:
 
         >>> _is_stable("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48")
         True
@@ -177,5 +189,6 @@ def _is_stable(token: Address) -> bool:
     See Also:
         - :data:`STABLECOINS`
         - :data:`INTL_STABLECOINS`
+        - :data:`STABLEISH_COINS`
     """
-    return token in STABLECOINS or token in INTL_STABLECOINS
+    return token in SORT_AS_STABLES or token in INTL_STABLECOINS

eth_portfolio/constants.py

@@ -28,8 +28,19 @@ ETH_LIKE: Final = {
         "0x5e74C9036fb86BD7eCdcb084a0673EFc32eA31cb",  # seth
         "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",  # eth
         "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",  # steth
+        "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",  # wstETH
         "0x9559Aaa82d9649C7A7b220E7c461d2E74c9a3593",  # reth
         "0xE95A203B1a91a908F9B9CE46459d101078c2c3cb",  # ankreth
+        "0x04C154b66CB340F3Ae24111CC767e0184Ed00Cc6",  # pxETH
+        "0x856c4Efb76C1D1AE02e20CEB03A2A6a08b0b8dC3",  # oETH
+        "0x0100546F2cD4C9D97f798fFC9755E47865FF7Ee6",  # alETH
+        "0x1BED97CBC3c24A4fb5C069C6E311a967386131f7",  # yETH
+        "0x24Ae2dA0f361AA4BE46b48EB19C91e02c5e4f27E",  # mevETH
+        "0x5E8422345238F34275888049021821E8E08CAa1f",  # frxETH
+        "0x821A278dFff762c76410264303F25bF42e195C0C",  # pETH
+        "0xBe9895146f7AF43049ca1c1AE358B0541Ea49704",  # cbETH
+        "0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee",  # weETH
+        "0x7C07F7aBe10CE8e33DC6C5aD68FE033085256A84",  # icETH
     },
 }.get(chain.id, set())
 
@@ -43,6 +54,8 @@ BTC_LIKE: Final = {
         "0x0316EB71485b0Ab14103307bf65a021042c6d380",  # hbtc
         "0x5228a22e72ccC52d415EcFd199F99D0665E7733b",  # pbtc
         "0x8dAEBADE922dF735c38C80C7eBD708Af50815fAa",  # tbtc
+        "0x66eFF5221ca926636224650Fd3B9c497FF828F7D",  # multiBTC
+        "0x657e8C867D8B37dCC18fA4Caead9C45EB088C642",  # eBTC
     },
 }.get(chain.id, set())
 
@@ -52,11 +65,18 @@ INTL_STABLECOINS: Final = {
         "0xC581b735A1688071A1746c968e0798D642EDE491",  # EURT
         "0xdB25f211AB05b1c97D595516F45794528a807ad8",  # EURS
         "0x96E61422b6A9bA0e068B6c5ADd4fFaBC6a4aae27",  # ibEUR
-        "0x269895a3dF4D73b077Fc823dD6dA1B95f72Aaf9B",  # sKRW
+        "0x9fcf418B971134625CdF38448B949C8640971671",  # EURN
+        "0x39b8B6385416f4cA36a20319F70D28621895279D",  # EURe
+        "0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c",  # EURC
         "0x3F1B0278A9ee595635B61817630cC19DE792f506",  # sAUD
+        "0xFAFdF0C4c1CB09d430Bf88c75D88BB46DAe09967",  # ibAUD
         "0x97fe22E7341a0Cd8Db6F6C021A24Dc8f4DAD855F",  # sGBP
+        "0x69681f8fde45345C3870BCD5eaf4A05a60E7D227",  # ibGBP
         "0xF6b1C627e95BFc3c1b4c9B825a032Ff0fBf3e07d",  # sJPY
+        "0x5555f75e3d5278082200Fb451D1b6bA946D8e13b",  # ibJPY
         "0x0F83287FF768D1c1e17a42F44d644D7F22e8ee1d",  # sCHF
+        "0x1CC481cE2BD2EC7Bf67d1Be64d4878b16078F309",  # ibCHF
         "0x269895a3dF4D73b077Fc823dD6dA1B95f72Aaf9B",  # sKRW
+        "0x95dFDC8161832e4fF7816aC4B6367CE201538253",  # ibKRW
     },
 }.get(chain.id, set())

eth_portfolio/portfolio.py

@@ -37,7 +37,7 @@ from eth_portfolio.typing import Addresses, PortfolioBalances
 logger = logging.getLogger(__name__)
 
 
-class PortfolioWallets(Iterable[PortfolioAddress], Dict[Address, PortfolioAddress]):  # type: ignore [misc]
+class PortfolioWallets(Iterable[PortfolioAddress], Dict[Address, PortfolioAddress]):  # type: ignore [metaclass]
     """
     A container that holds all :class:`~eth_portfolio.address.PortfolioAddress` objects for a specific :class:`~eth_portfolio.Portfolio`.
 

eth_portfolio/protocols/lending/liquity.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from async_lru import alru_cache
+from faster_async_lru import alru_cache
 from y import Contract, Network, get_price
 from y._decorators import stuck_coro_debugger
 from y.constants import EEE_ADDRESS

eth_portfolio/protocols/lending/maker.py

@@ -1,10 +1,12 @@
 from asyncio import gather
-from typing import List, Optional
+from typing import Final, List, Optional
 
 from a_sync import igather
-from async_lru import alru_cache
+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
@@ -14,18 +16,15 @@ from eth_portfolio._utils import Decimal
 from eth_portfolio.protocols.lending._base import LendingProtocolWithLockedCollateral
 from eth_portfolio.typing import Balance, TokenBalances
 
-try:
-    # this is only available in 4.0.0+
-    from eth_abi import encode
 
-    encode_bytes = lambda bytestring: encode(["bytes32"], [bytestring])
-except ImportError:
-    from eth_abi import encode_single
+yfi: Final = "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e"
+dai: Contract
+_1e18: Final = Decimal(10**18)
+_1e45: Final = Decimal(10**45)
 
-    encode_bytes = lambda bytestring: encode_single("bytes32", bytestring)
 
-yfi = "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e"
-dai: Contract
+def encode_bytes(bytestring: str) -> bytes:
+    return encode(["bytes32"], [bytestring])
 
 
 class Maker(LendingProtocolWithLockedCollateral):
@@ -50,8 +49,8 @@ class Maker(LendingProtocolWithLockedCollateral):
 
         balances: TokenBalances = TokenBalances(block=block)
         for token, data in zip(gems, ink_data):
-            if ink := data.dict()["ink"]:
-                balance = ink / Decimal(10**18)
+            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
@@ -75,7 +74,7 @@ class Maker(LendingProtocolWithLockedCollateral):
         for urns, ilk_info in data:
             art = urns.dict()["art"]
             rate = ilk_info.dict()["rate"]
-            debt = art * rate / Decimal(1e45)
+            debt = art * rate / _1e45
             balances[dai.address] += Balance(debt, debt, token=dai, block=block)
         return balances
 

eth_portfolio/structs/structs.py

@@ -80,7 +80,7 @@ class _LedgerEntryBase(DictStruct, kw_only=True, frozen=True, omit_defaults=True
     The USD value of the cryptocurrency transferred in the {cls_name}, if price is known.
     """
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
 
         # Replace {cls_name} in attribute-level docstrings
@@ -273,7 +273,7 @@ class _TransactionBase(
         return self.transaction.yParity
 
     @property
-    def __db_primary_key__(self):
+    def __db_primary_key__(self) -> Dict[str, tuple[int, Address] | int]:
         return {"from_address": (chain.id, self.from_address), "nonce": self.nonce}
 
 

eth_portfolio/typing/__init__.py

@@ -43,10 +43,10 @@ from typing import (
 )
 
 from checksum_dict import DefaultChecksumDict
-from eth_typing import BlockNumber
+from eth_typing import BlockNumber, HexAddress
 from pandas import DataFrame, concat
 from typing_extensions import ParamSpec, Self
-from y import ERC20
+from y import Contract, ERC20
 from y.datatypes import Address
 
 from eth_portfolio._decimal import Decimal
@@ -159,10 +159,10 @@ class TokenBalances(DefaultChecksumDict[Balance], _SummableNonNumericMixin):  #
                     raise
                 self[token.address] += balance
 
-    def __getitem__(self, key) -> Balance:
+    def __getitem__(self, key: HexAddress) -> Balance:
         return super().__getitem__(key) if key in self else Balance(token=key, block=self.block)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: HexAddress, value: Balance) -> None:
         """
         Sets the balance for a given token address.
 
@@ -393,7 +393,7 @@ class RemoteTokenBalances(DefaultDict[ProtocolLabel, TokenBalances], _SummableNo
                 )
             self[remote] += token_balances  # type: ignore [has-type]
 
-    def __setitem__(self, protocol: str, value: TokenBalances):
+    def __setitem__(self, protocol: str, value: TokenBalances) -> None:
         """
         Sets the token balances for a given protocol.
 
@@ -911,7 +911,7 @@ class PortfolioBalances(DefaultChecksumDict[WalletBalances], _SummableNonNumeric
                 )
             self[wallet] += balances
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: HexAddress, value: WalletBalances) -> None:
         if not isinstance(value, WalletBalances):
             raise TypeError(
                 f"value must be a `WalletBalances` object. You passed {value}"

eth_portfolio_scripts/_portfolio.py

@@ -1,3 +1,4 @@
+import asyncio
 from datetime import datetime, timezone
 from logging import getLogger
 from math import floor
@@ -5,10 +6,11 @@ from typing import Awaitable, Callable, Final, Iterator, List, Optional, Tuple
 
 import a_sync
 import eth_retry
+import y
 from a_sync.functools import cached_property_unsafe as cached_property
 from eth_typing import BlockNumber, ChecksumAddress
 from msgspec import ValidationError, json
-from y import ERC20, Network, NonStandardERC20, get_block_at_timestamp
+from y import ERC20, Network, NonStandardERC20
 from y.constants import CHAINID
 from y.time import NoBlockFound
 
@@ -33,6 +35,19 @@ logger: Final = getLogger("eth_portfolio")
 log_debug: Final = logger.debug
 log_error: Final = logger.error
 
+_block_at_timestamp_semaphore: Final = a_sync.Semaphore(
+    50, name="eth-portfolio get_block_at_timestamp"
+)
+
+
+async def get_block_at_timestamp(dt: datetime) -> BlockNumber:
+    async with _block_at_timestamp_semaphore:
+        while True:
+            try:
+                return await y.get_block_at_timestamp(dt, sync=False)
+            except NoBlockFound:
+                await asyncio.sleep(10)
+
 
 class ExportablePortfolio(Portfolio):
     """Adds methods to export full portoflio data."""
@@ -40,8 +55,10 @@ class ExportablePortfolio(Portfolio):
     def __init__(
         self,
         addresses: Addresses,
+        *,
         start_block: int = 0,
         label: str = _DEFAULT_LABEL,
+        concurrency: int = 40,
         load_prices: bool = True,
         get_bucket: Callable[[ChecksumAddress], Awaitable[str]] = get_token_bucket,
         num_workers_transactions: int = 1000,
@@ -51,6 +68,7 @@ class ExportablePortfolio(Portfolio):
             addresses, start_block, label, load_prices, num_workers_transactions, asynchronous
         )
         self.get_bucket = get_bucket
+        self._semaphore = a_sync.Semaphore(concurrency)
 
     @cached_property
     def _data_queries(self) -> Tuple[str, str]:
@@ -71,53 +89,48 @@ class ExportablePortfolio(Portfolio):
                 return True
         return False
 
-    async def export_snapshot(self, dt: datetime):
+    async def export_snapshot(self, dt: datetime) -> None:
         log_debug("checking data at %s for %s", dt, self.label)
         try:
-            if not await self.data_exists(dt, sync=False):
-                while True:
-                    try:
-                        block = await get_block_at_timestamp(dt, sync=False)
-                    except NoBlockFound:
-                        pass
-                    else:
-                        break
-                log_debug("block at %s: %s", dt, block)
-                data = await self.get_data_for_export(block, dt, sync=False)
-                await victoria.post_data(data)
+            if await self.data_exists(dt, sync=False):
+                return
+            block = await get_block_at_timestamp(dt)
+            log_debug("block at %s: %s", dt, block)
+            data = await self.get_data_for_export(block, dt, sync=False)
+            await victoria.post_data(data)
         except Exception as e:
             log_error("Error processing %s:", dt, exc_info=True)
 
-    @a_sync.Semaphore(60)
     async def get_data_for_export(self, block: BlockNumber, ts: datetime) -> List[victoria.Metric]:
-        print(f"exporting {ts} for {self.label}")
-        start = datetime.now(tz=timezone.utc)
-
-        metrics_to_export = []
-        data: PortfolioBalances = await self.describe(block, sync=False)
-
-        for wallet, wallet_data in dict.items(data):
-            for section, section_data in wallet_data.items():
-                if isinstance(section_data, TokenBalances):
-                    for token, bals in dict.items(section_data):
-                        metrics_to_export.extend(
-                            await self.__process_token(ts, section, wallet, token, bals)
-                        )
-                elif isinstance(section_data, RemoteTokenBalances):
-                    if section == "external":
-                        section = "assets"
-                    for protocol, token_bals in section_data.items():
-                        for token, bals in dict.items(token_bals):
+        async with self._semaphore:
+            print(f"exporting {ts} for {self.label}")
+            start = datetime.now(tz=timezone.utc)
+
+            metrics_to_export = []
+            data: PortfolioBalances = await self.describe(block, sync=False)
+
+            for wallet, wallet_data in dict.items(data):
+                for section, section_data in wallet_data.items():
+                    if isinstance(section_data, TokenBalances):
+                        for token, bals in dict.items(section_data):
                             metrics_to_export.extend(
-                                await self.__process_token(
-                                    ts, section, wallet, token, bals, protocol=protocol
-                                )
+                                await self.__process_token(ts, section, wallet, token, bals)
                             )
-                else:
-                    raise NotImplementedError()
+                    elif isinstance(section_data, RemoteTokenBalances):
+                        if section == "external":
+                            section = "assets"
+                        for protocol, token_bals in section_data.items():
+                            for token, bals in dict.items(token_bals):
+                                metrics_to_export.extend(
+                                    await self.__process_token(
+                                        ts, section, wallet, token, bals, protocol=protocol
+                                    )
+                                )
+                    else:
+                        raise NotImplementedError()
 
-        print(f"got data for {ts} in {datetime.now(tz=timezone.utc) - start}")
-        return metrics_to_export
+            print(f"got data for {ts} in {datetime.now(tz=timezone.utc) - start}")
+            return metrics_to_export
 
     def __get_data_exists_coros(self, dt: datetime) -> Iterator[str]:
         for query in self._data_queries:
@@ -131,7 +144,7 @@ class ExportablePortfolio(Portfolio):
         token: ChecksumAddress,
         bal: Balance,
         protocol: Optional[str] = None,
-    ):
+    ) -> Tuple[victoria.types.PrometheusItem, victoria.types.PrometheusItem]:
         # TODO wallet nicknames in grafana
         # wallet = KNOWN_ADDRESSES[wallet] if wallet in KNOWN_ADDRESSES else wallet
         if protocol is not None:
@@ -172,7 +185,7 @@ class ExportablePortfolio(Portfolio):
         )
 
 
-async def _get_symbol(token) -> str:
+async def _get_symbol(token: str) -> str:
     if token == "ETH":
         return "ETH"
     try:

eth_portfolio_scripts/_utils.py

@@ -1,18 +1,18 @@
 import re
 from asyncio import Task, create_task, sleep
 from datetime import datetime, timedelta, timezone
-from typing import Any, AsyncGenerator, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, Final, List, Optional
 
 from brownie import chain
 
 
-def parse_timedelta(value: str) -> timedelta:
-    regex = re.compile(r"(\d+)([dhms]?)")
-    result = regex.findall(value)
+timedelta_pattern: Final = re.compile(r"(\d+)([dhms]?)")
+
 
+def parse_timedelta(value: str) -> timedelta:
     days, hours, minutes, seconds = 0, 0, 0, 0
 
-    for val, unit in result:
+    for val, unit in timedelta_pattern.findall(value):
         val = int(val)
         if unit == "d":
             days = val
@@ -58,10 +58,24 @@ async def aiter_timestamps(
 
     timestamp = start
 
+    timestamps = []
     while timestamp <= datetime.now(tz=timezone.utc):
-        yield timestamp
+        timestamps.append(timestamp)
         timestamp = timestamp + interval
 
+    # cycle between yielding earliest, latest, and middle from `timestamps` until complete
+    while timestamps:
+        # yield the earliest timestamp
+        yield timestamps.pop(0)
+        # yield the most recent timestamp if there is one
+        if timestamps:
+            yield timestamps.pop(-1)
+            # yield the most middle timestamp if there is one
+            if timestamps:
+                yield timestamps.pop(len(timestamps) // 2)
+
+    del timestamps
+
     while run_forever:
         while timestamp > datetime.now(tz=timezone.utc):
             await _get_waiter(timestamp)

eth_portfolio_scripts/balances.py

@@ -26,13 +26,16 @@ async def export_balances(args: Namespace) -> None:
 
     interval = parse_timedelta(args.interval)
     portfolio = ExportablePortfolio(
-        args.wallet, label=args.label, start_block=args.first_tx_block, load_prices=False
+        args.wallet,
+        label=args.label,
+        start_block=args.first_tx_block,
+        concurrency=args.concurrency,
+        load_prices=False,
     )
 
     if export_start_block := args.export_start_block or args.first_tx_block:
-        start = datetime.fromtimestamp(
-            await dank_mids.eth.get_block_timestamp(args.export_start_block), tz=timezone.utc
-        )
+        start_ts = await dank_mids.eth.get_block_timestamp(export_start_block)
+        start = datetime.fromtimestamp(start_ts, tz=timezone.utc)
     else:
         start = None