mm-eth 0.5.9__tar.gz → 0.7.0__tar.gz

mm_eth-0.7.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: mm-eth
+Version: 0.7.0
+Requires-Python: >=3.13
+Requires-Dist: mm-cryptocurrency>=0.4.7
+Requires-Dist: mm-std>=0.5.3
+Requires-Dist: typer~=0.16.0
+Requires-Dist: web3~=7.12.0

{mm_eth-0.5.9 → mm_eth-0.7.0}/justfile

@@ -20,7 +20,9 @@ lint: format
     uv run mypy src
 
 audit:
-    uv run pip-audit
+    uv export --no-dev --all-extras --format requirements-txt --no-emit-project > requirements.txt
+    uv run pip-audit -r requirements.txt --disable-pip
+    rm requirements.txt
     uv run bandit -r -c "pyproject.toml" src
 
 publish: build

mm_eth-0.7.0/pyproject.toml

@@ -0,0 +1,89 @@
+[project]
+name = "mm-eth"
+version = "0.7.0"
+description = ""
+requires-python = ">=3.13"
+dependencies = [
+    # "websocket-client~=1.8.0",
+    "web3~=7.12.0",
+    "typer~=0.16.0",
+    "mm-cryptocurrency>=0.4.7",
+    "mm-std>=0.5.3",
+]
+[project.scripts]
+mm-eth = "mm_eth.cli.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv]
+dev-dependencies = [
+    "pytest~=8.4.0",
+    "pytest-asyncio~=1.0.0",
+    "pytest-xdist~=3.7.0",
+    "ruff~=0.11.13",
+    "pip-audit~=2.9.0",
+    "bandit~=1.8.3",
+    "mypy~=1.16.0",
+    "python-dotenv>=1.1.0",
+]
+
+[tool.mypy]
+python_version = "3.13"
+mypy_path = "stubs"
+warn_no_return = false
+implicit_reexport = true
+strict = true
+enable_error_code = ["truthy-bool", "possibly-undefined"]
+exclude = ["^tests/", "^tmp/"]
+[[tool.mypy.overrides]]
+module = ["rlp", "rlp.sedes", "ens.utils", "ens"]
+ignore_missing_imports = true
+
+[tool.ruff]
+line-length = 130
+target-version = "py313"
+[tool.ruff.lint]
+select = ["ALL"]
+# fixable = ["F401"]
+ignore = [
+    "TC", # flake8-type-checking, TYPE_CHECKING is dangerous, for example it doesn't work with pydantic
+    "A005", # flake8-builtins: stdlib-module-shadowing
+    "ERA001", # eradicate: commented-out-code
+    "PT", # flake8-pytest-style
+    "D", # pydocstyle
+    "FIX", # flake8-fixme
+    "PLR0911", # pylint: too-many-return-statements
+    "PLR0912", # pylint: too-many-branches
+    "PLR0913", # pylint: too-many-arguments
+    "PLR2004", # pylint: magic-value-comparison
+    "PLC0414", # pylint: useless-import-alias
+    "FBT", # flake8-boolean-trap
+    "EM", # flake8-errmsg
+    "TRY003", # tryceratops: raise-vanilla-args
+    "C901", # mccabe: complex-structure,
+    "BLE001", # flake8-blind-except
+    "S311", # bandit: suspicious-non-cryptographic-random-usage
+    "TD002", # flake8-todos: missing-todo-author
+    "TD003", # flake8-todos: missing-todo-link
+    "RET503", # flake8-return: implicit-return
+    "COM812", # it's used in ruff formatter
+    "ASYNC109", # flake8-async: async-function-with-timeout
+    "G004",
+]
+[tool.ruff.lint.pep8-naming]
+classmethod-decorators = ["field_validator"]
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = ["ANN", "S"]
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.bandit]
+exclude_dirs = ["tests"]
+skips = ["B311"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

{mm_eth-0.5.9 → mm_eth-0.7.0}/src/mm_eth/abi.py

@@ -11,8 +11,6 @@ from pydantic import BaseModel
 from web3 import Web3
 from web3.auto import w3
 
-from mm_eth.utils import hex_to_bytes
-
 
 @dataclass
 class NameTypeValue:
@@ -74,7 +72,7 @@ def encode_function_input_by_abi(abi: ABI | ABIFunction, fn_name: str, args: lis
     # if abi is contract_abi, get function_abi
     if isinstance(abi, Sequence):
         abi = get_function_abi(abi, fn_name)
-    abi = cast(ABIFunction, abi)
+    # abi = cast(ABIFunction, abi)
 
     # need update all address values to checkSum version
     processed_args = []
@@ -99,7 +97,7 @@ def encode_function_input_by_signature(func_signature: str, args: list[Any]) ->
     func_abi: ABIFunction = {
         "name": func_name,
         "type": "function",
-        "inputs": [{"type": t} for t in arg_types],  # type: ignore[typeddict-item]
+        "inputs": [{"type": t} for t in arg_types],
     }
     return encode_function_input_by_abi(func_abi, func_name, args)
 
@@ -110,7 +108,7 @@ def encode_function_signature(func_name_with_types: str) -> HexStr:
 
 
 def decode_data(types: list[str], data: str) -> tuple[Any, ...]:
-    return eth_abi.decode(types, hex_to_bytes(data))
+    return eth_abi.decode(types, eth_utils.to_bytes(hexstr=HexStr(data)))
 
 
 def encode_data(types: list[str], args: list[Any]) -> str:

mm_eth-0.7.0/src/mm_eth/account.py

@@ -0,0 +1,104 @@
+from dataclasses import dataclass
+
+import eth_utils
+from eth_account import Account
+from eth_account.hdaccount import Mnemonic
+from eth_account.signers.local import LocalAccount
+from eth_account.types import Language
+from eth_keys import KeyAPI
+from mm_result import Result
+
+Account.enable_unaudited_hdwallet_features()
+
+key_api = KeyAPI()
+
+# Default derivation path template for Ethereum HD wallets
+DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/{i}"
+
+
+@dataclass
+class DerivedAccount:
+    """Represents an account derived from a mnemonic phrase."""
+
+    index: int
+    path: str
+    address: str
+    private_key: str
+
+
+def generate_mnemonic(num_words: int = 24) -> str:
+    """
+    Generates a BIP39 mnemonic phrase in English.
+
+    Args:
+        num_words (int): Number of words in the mnemonic (12, 15, 18, 21, or 24).
+
+    Returns:
+        str: Generated mnemonic phrase.
+    """
+    mnemonic = Mnemonic(Language.ENGLISH)
+    return mnemonic.generate(num_words=num_words)
+
+
+def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit: int) -> list[DerivedAccount]:
+    """
+    Derives multiple Ethereum accounts from a given mnemonic phrase.
+
+    Args:
+        mnemonic (str): BIP39 mnemonic phrase.
+        passphrase (str): Optional BIP39 passphrase.
+        derivation_path (str): Path template with '{i}' as index placeholder.
+        limit (int): Number of accounts to derive.
+
+    Raises:
+        ValueError: If derivation_path does not contain '{i}'.
+
+    Returns:
+        list[DerivedAccount]: List of derived Ethereum accounts.
+    """
+    if "{i}" not in derivation_path:
+        raise ValueError("derivation_path must contain {i}, for example: " + DEFAULT_DERIVATION_PATH)
+
+    result: list[DerivedAccount] = []
+    for i in range(limit):
+        path = derivation_path.replace("{i}", str(i))
+        acc = Account.from_mnemonic(mnemonic, passphrase, path)
+        private_key = acc.key.to_0x_hex().lower()
+        result.append(DerivedAccount(i, path, acc.address, private_key))
+    return result
+
+
+def private_to_address(private_key: str, lower: bool = False) -> Result[str]:
+    """
+    Converts a private key to its corresponding Ethereum address.
+
+    Args:
+        private_key (str): Hex-encoded private key.
+        lower (bool): Whether to return address in lowercase.
+
+    Returns:
+        Result[str]: Ok(address) or Err(exception) on failure.
+    """
+    try:
+        acc: LocalAccount = Account.from_key(private_key)
+        address = acc.address.lower() if lower else acc.address
+        return Result.ok(address)
+    except Exception as e:
+        return Result.err(e)
+
+
+def is_private_key(private_key: str) -> bool:
+    """
+    Checks if a given hex string is a valid Ethereum private key.
+
+    Args:
+        private_key (str): Hex-encoded private key.
+
+    Returns:
+        bool: True if valid, False otherwise.
+    """
+    try:
+        key_api.PrivateKey(eth_utils.decode_hex(private_key)).public_key.to_address()
+        return True  # noqa: TRY300
+    except Exception:
+        return False

{mm_eth-0.5.9 → mm_eth-0.7.0}/src/mm_eth/anvil.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import socket
 import time
 from subprocess import Popen  # nosec
+from typing import cast
 
-from mm_std import Err, Ok, Result
-from mm_std.net import get_free_local_port
+from mm_result import Result
 
 from mm_eth import account, rpc
 
@@ -25,16 +26,16 @@ class Anvil:
         if self.process:
             self.process.kill()
 
-    def check(self) -> bool:
-        res = rpc.eth_chain_id(self.rpc_url)
-        return isinstance(res, Ok) and res.ok == self.chain_id
+    async def check(self) -> bool:
+        res = await rpc.eth_chain_id(self.rpc_url)
+        return res.is_ok() and res.unwrap() == self.chain_id
 
     @property
     def rpc_url(self) -> str:
         return f"http://localhost:{self.port}"
 
     @classmethod
-    def launch(
+    async def launch(
         cls,
         chain_id: int = 31337,
         port: int | None = None,
@@ -49,8 +50,16 @@ class Anvil:
                 port = get_free_local_port()
             anvil = Anvil(chain_id=chain_id, port=port, mnemonic=mnemonic)
             anvil.start_process()
-            if anvil.check():
-                return Ok(anvil)
+            if await anvil.check():
+                return Result.ok(anvil)
             port = get_free_local_port()
 
-        return Err("can't lauch anvil")
+        return Result.err("can't launch anvil")
+
+
+def get_free_local_port() -> int:
+    sock = socket.socket()
+    sock.bind(("", 0))
+    port = sock.getsockname()[1]
+    sock.close()
+    return cast(int, port)

mm_eth-0.7.0/src/mm_eth/cli/calcs.py

@@ -0,0 +1,11 @@
+import mm_cryptocurrency
+
+from mm_eth.cli.validators import SUFFIX_DECIMALS
+
+
+def calc_eth_expression(expression: str, variables: dict[str, int] | None = None) -> int:
+    return mm_cryptocurrency.calc_expression_with_vars(expression, variables, unit_decimals=SUFFIX_DECIMALS)
+
+
+def calc_token_expression(expression: str, token_decimals: int, variables: dict[str, int] | None = None) -> int:
+    return mm_cryptocurrency.calc_expression_with_vars(expression, variables, unit_decimals={"t": token_decimals})

mm_eth-0.7.0/src/mm_eth/cli/cli.py

@@ -0,0 +1,138 @@
+import asyncio
+import importlib.metadata
+from pathlib import Path
+from typing import Annotated
+
+import mm_print
+import typer
+
+from mm_eth.account import DEFAULT_DERIVATION_PATH
+from mm_eth.cli.cli_utils import PrintFormat
+from mm_eth.cli.cmd import balance_cmd, balances_cmd, deploy_cmd, node_cmd, solc_cmd, transfer_cmd
+from mm_eth.cli.cmd.balances_cmd import BalancesCmdParams
+from mm_eth.cli.cmd.deploy_cmd import DeployCmdParams
+from mm_eth.cli.cmd.transfer_cmd import TransferCmdParams
+from mm_eth.cli.cmd.wallet import mnemonic_cmd, private_key_cmd
+
+app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
+
+wallet_app = typer.Typer(no_args_is_help=True, help="Wallet commands: generate mnemonic, private to address")
+app.add_typer(wallet_app, name="wallet")
+app.add_typer(wallet_app, name="w", hidden=True)
+
+
+@wallet_app.command(name="mnemonic", help="Generate eth accounts based on a mnemonic")
+def mnemonic_command(  # nosec
+    mnemonic: Annotated[str, typer.Option("--mnemonic", "-m")] = "",
+    passphrase: Annotated[str, typer.Option("--passphrase", "-p")] = "",
+    print_path: bool = typer.Option(False, "--print_path"),
+    derivation_path: Annotated[str, typer.Option("--path")] = DEFAULT_DERIVATION_PATH,
+    words: int = typer.Option(12, "--words", "-w", help="Number of mnemonic words"),
+    limit: int = typer.Option(10, "--limit", "-l"),
+    save_file: str = typer.Option("", "--save", "-s", help="Save private keys to a file"),
+) -> None:
+    mnemonic_cmd.run(
+        mnemonic,
+        passphrase=passphrase,
+        print_path=print_path,
+        limit=limit,
+        words=words,
+        derivation_path=derivation_path,
+        save_file=save_file,
+    )
+
+
+@wallet_app.command(name="private-key", help="Print an address for a private key")
+def private_key_command(private_key: str) -> None:
+    private_key_cmd.run(private_key)
+
+
+@app.command(name="node", help="Check RPC url")
+def node_command(
+    urls: Annotated[list[str], typer.Argument()],
+    proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.TABLE,
+) -> None:
+    asyncio.run(node_cmd.run(urls, proxy, print_format))
+
+
+@app.command(name="balance", help="Gen account balance")
+def balance_command(
+    wallet_address: Annotated[str, typer.Argument()],
+    token_address: Annotated[str | None, typer.Option("--token", "-t")] = None,
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL")] = "",  # nosec
+    wei: bool = typer.Option(False, "--wei", "-w", help="Print balances in wei units"),
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
+) -> None:
+    asyncio.run(balance_cmd.run(rpc_url, wallet_address, token_address, wei, print_format))
+
+
+@app.command(name="balances", help="Print base and ERC20 token balances")
+def balances_command(
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    nonce: bool = typer.Option(False, "--nonce", "-n", help="Print nonce also"),
+    wei: bool = typer.Option(False, "--wei", "-w", help="Show balances in WEI"),
+) -> None:
+    asyncio.run(
+        balances_cmd.run(BalancesCmdParams(config_path=config_path, print_config=print_config, wei=wei, show_nonce=nonce))
+    )
+
+
+@app.command(name="solc", help="Compile a solidity file")
+def solc_command(
+    contract_path: Path,
+    tmp_dir: Path = Path("/tmp"),  # noqa: S108 # nosec
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
+) -> None:
+    solc_cmd.run(contract_path, tmp_dir, print_format)
+
+
+@app.command(name="deploy", help="Deploy a smart contract onchain")
+def deploy_command(
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+) -> None:
+    asyncio.run(deploy_cmd.run(DeployCmdParams(config_path=config_path, print_config=print_config)))
+
+
+@app.command(
+    name="transfer", help="Transfers ETH or ERC20 tokens, supporting multiple routes, delays, and expression-based values"
+)
+def transfer_command(
+    config_path: Path,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances and exit"),
+    print_transfers: bool = typer.Option(False, "--transfers", "-t", help="Print transfers (from, to, value) and exit"),
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    emulate: bool = typer.Option(False, "--emulate", "-e", help="Emulate transaction posting"),
+    skip_receipt: bool = typer.Option(False, "--skip-receipt", help="Don't wait for a tx receipt"),
+    debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
+) -> None:
+    asyncio.run(
+        transfer_cmd.run(
+            TransferCmdParams(
+                config_path=config_path,
+                print_balances=print_balances,
+                print_transfers=print_transfers,
+                print_config=print_config,
+                debug=debug,
+                skip_receipt=skip_receipt,
+                emulate=emulate,
+            )
+        )
+    )
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        mm_print.plain(f"mm-eth: {importlib.metadata.version('mm-eth')}")
+        raise typer.Exit
+
+
+@app.callback()
+def main(_version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=True)) -> None:
+    pass
+
+
+if __name__ == "__main_":
+    app()

mm_eth-0.7.0/src/mm_eth/cli/cli_utils.py

@@ -0,0 +1,57 @@
+import importlib.metadata
+from enum import Enum, unique
+from pathlib import Path
+
+import mm_print
+from pydantic import BaseModel
+from rich.table import Table
+
+from mm_eth import rpc
+
+
+@unique
+class PrintFormat(str, Enum):
+    PLAIN = "plain"
+    TABLE = "table"
+    JSON = "json"
+
+
+def public_rpc_url(url: str | None) -> str:
+    if not url or url == "1":
+        return "https://ethereum-rpc.publicnode.com"
+    if url.startswith(("http://", "https://", "ws://", "wss://")):
+        return url
+
+    match url.lower():
+        case "mainnet" | "1":
+            return "https://ethereum-rpc.publicnode.com"
+        case "sepolia" | "11155111":
+            return "https://ethereum-sepolia-rpc.publicnode.com"
+        case "opbnb" | "204":
+            return "https://opbnb-mainnet-rpc.bnbchain.org"
+        case "base" | "8453":
+            return "https://mainnet.base.org"
+        case "base-sepolia" | "84532":
+            return "https://sepolia.base.org"
+        case _:
+            return url
+
+
+class BaseConfigParams(BaseModel):
+    config_path: Path
+    print_config: bool
+
+
+async def check_nodes_for_chain_id(nodes: list[str], chain_id: int) -> None:
+    for node in nodes:
+        res = (await rpc.eth_chain_id(node)).unwrap("can't get chain_id")
+        if res != chain_id:
+            mm_print.fatal(f"node {node} has a wrong chain_id: {res}")
+
+
+def add_table_raw(table: Table, *row: object) -> None:
+    table.add_row(*[str(cell) for cell in row])
+
+
+def get_version() -> str:
+    return importlib.metadata.version("mm-eth")

mm_eth-0.7.0/src/mm_eth/cli/cmd/balance_cmd.py

@@ -0,0 +1,47 @@
+import eth_utils
+import mm_print
+
+from mm_eth import converters, rpc
+from mm_eth.cli import cli_utils
+from mm_eth.cli.cli import PrintFormat
+
+
+async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool, print_format: PrintFormat) -> None:
+    result: dict[str, object] = {}
+    rpc_url = cli_utils.public_rpc_url(rpc_url)
+
+    # nonce
+    result["nonce"] = (await rpc.eth_get_transaction_count(rpc_url, wallet_address)).value_or_error()
+    if print_format == PrintFormat.PLAIN:
+        mm_print.plain(f"nonce: {result['nonce']}")
+
+    # eth balance
+    result["eth_balance"] = (
+        (await rpc.eth_get_balance(rpc_url, wallet_address))
+        .map(lambda value: value if wei else eth_utils.from_wei(value, "ether"))
+        .value_or_error()
+    )
+    if print_format == PrintFormat.PLAIN:
+        mm_print.plain(f"eth_balance: {result['eth_balance']}")
+
+    if token_address:
+        # token decimal
+        result["token_decimal"] = (await rpc.erc20_decimals(rpc_url, token_address)).value_or_error()
+        if print_format == PrintFormat.PLAIN:
+            mm_print.plain(f"token_decimal: {result['token_decimal']}")
+
+        # token symbol
+        result["token_symbol"] = (await rpc.erc20_symbol(rpc_url, token_address)).value_or_error()
+        if print_format == PrintFormat.PLAIN:
+            mm_print.plain(f"token_symbol: {result['token_symbol']}")
+
+        # token balance
+        result["token_balance"] = (await rpc.erc20_balance(rpc_url, token_address, wallet_address)).value_or_error()
+        if isinstance(result["token_balance"], int) and not wei and isinstance(result["token_decimal"], int):
+            result["token_balance"] = converters.from_wei(result["token_balance"], "t", decimals=result["token_decimal"])
+
+        if print_format == PrintFormat.PLAIN:
+            mm_print.plain(f"token_balance: {result['token_balance']}")
+
+    if print_format == PrintFormat.JSON:
+        mm_print.json(data=result)

mm_eth-0.7.0/src/mm_eth/cli/cmd/balances_cmd.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass
+from typing import Annotated
+
+import mm_print
+from mm_cryptocurrency import CryptocurrencyConfig
+from pydantic import BeforeValidator
+from rich.live import Live
+from rich.table import Table
+
+from mm_eth import converters, retry
+from mm_eth.cli.cli_utils import BaseConfigParams
+from mm_eth.cli.validators import Validators
+
+
+class Config(CryptocurrencyConfig):
+    addresses: Annotated[list[str], BeforeValidator(Validators.eth_addresses(unique=True))]
+    tokens: Annotated[list[str], BeforeValidator(Validators.eth_addresses(unique=True))]
+    nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
+    round_ndigits: int = 5
+
+
+@dataclass
+class Token:
+    address: str
+    decimals: int
+    symbol: str
+
+
+class BalancesCmdParams(BaseConfigParams):
+    wei: bool
+    show_nonce: bool
+
+
+async def run(params: BalancesCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(params.config_path)
+    if params.print_config:
+        config.print_and_exit()
+
+    tokens = await _get_tokens_info(config)
+
+    table = Table(title="balances")
+    table.add_column("address")
+    if params.show_nonce:
+        table.add_column("nonce")
+    table.add_column("wei" if params.wei else "eth")
+    for t in tokens:
+        table.add_column(t.symbol)
+
+    base_sum = 0
+    token_sum: dict[str, int] = {t.address: 0 for t in tokens}
+    with Live(table, refresh_per_second=0.5):
+        for address in config.addresses:
+            row = [address]
+            if params.show_nonce:
+                nonce = await retry.eth_get_transaction_count(5, config.nodes, None, address=address)
+                row.append(str(nonce.value_or_error()))
+
+            base_balance_res = await retry.eth_get_balance(5, config.nodes, None, address=address)
+            if base_balance_res.is_ok():
+                balance = base_balance_res.unwrap()
+                base_sum += balance
+                if params.wei:
+                    row.append(str(balance))
+                else:
+                    row.append(str(converters.from_wei(balance, "eth", round_ndigits=config.round_ndigits)))
+            else:
+                row.append(base_balance_res.unwrap_err())
+
+            for t in tokens:
+                token_balance_res = await retry.erc20_balance(5, config.nodes, None, token=t.address, wallet=address)
+                if token_balance_res.is_ok():
+                    token_balance = token_balance_res.unwrap()
+                    token_sum[t.address] += token_balance
+                    if params.wei:
+                        row.append(str(token_balance))
+                    else:
+                        row.append(
+                            str(converters.from_wei(token_balance, "t", round_ndigits=config.round_ndigits, decimals=t.decimals))
+                        )
+                else:
+                    row.append(token_balance_res.unwrap_err())
+
+            table.add_row(*row)
+
+        sum_row = ["sum"]
+        if params.show_nonce:
+            sum_row.append("")
+        if params.wei:
+            sum_row.append(str(base_sum))
+            sum_row.extend([str(token_sum[t.address]) for t in tokens])
+        else:
+            sum_row.append(str(converters.from_wei(base_sum, "eth", round_ndigits=config.round_ndigits)))
+            sum_row.extend(
+                [
+                    str(converters.from_wei(token_sum[t.address], "t", round_ndigits=config.round_ndigits, decimals=t.decimals))
+                    for t in tokens
+                ]
+            )
+
+        table.add_row(*sum_row)
+
+
+async def _get_tokens_info(config: Config) -> list[Token]:
+    result: list[Token] = []
+    for address in config.tokens:
+        decimals_res = await retry.erc20_decimals(5, config.nodes, None, token=address)
+        if decimals_res.is_err():
+            mm_print.fatal(f"can't get token {address} decimals: {decimals_res.unwrap_err()}")
+        decimal = decimals_res.unwrap()
+
+        symbols_res = await retry.erc20_symbol(5, config.nodes, None, token=address)
+        if symbols_res.is_err():
+            mm_print.fatal(f"can't get token {address} symbol: {symbols_res.unwrap_err()}")
+        symbol = symbols_res.unwrap()
+
+        result.append(Token(address=address, decimals=decimal, symbol=symbol))
+
+    return result