mm-eth 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

mm_eth/abi.py

@@ -64,7 +64,7 @@ def decode_function_input(contract_abi: ABI, tx_input: str) -> FunctionInput:
 
 
 def get_function_abi(contr_abi: ABI, fn_name: str) -> ABIFunction:
-    abi = pydash.find(contr_abi, lambda x: x.get("name", None) == fn_name and x.get("type", None) == "function")  # type:ignore
+    abi = pydash.find(contr_abi, lambda x: x.get("name", None) == fn_name and x.get("type", None) == "function")  # type: ignore[call-overload, attr-defined]
     if not abi:
         raise ValueError("can't find abi for function: " + fn_name)
     return cast(ABIFunction, abi)
@@ -122,8 +122,8 @@ def parse_function_signatures(contract_abi: ABI) -> dict[str, str]:
     result: dict[str, str] = {}
     for item in contract_abi:
         if item.get("type", None) == "function":
-            function_name = item["name"]  # type: ignore
-            types = ",".join([i["type"] for i in item["inputs"]])  # type: ignore
+            function_name = item["name"]  # type: ignore[typeddict-item]
+            types = ",".join([i["type"] for i in item["inputs"]])  # type: ignore[typeddict-item]
             function_name_and_types = f"{function_name}({types})"
             result[function_name_and_types] = encode_function_signature(function_name_and_types)
     return result

mm_eth/account.py

@@ -67,6 +67,6 @@ def create_private_keys_dict(private_keys: list[str]) -> dict[str, str]:  # addr
 def is_private_key(private_key: str) -> bool:
     try:
         key_api.PrivateKey(decode_hex(private_key)).public_key.to_address()
-        return True
+        return True  # noqa: TRY300
     except Exception:
         return False

mm_eth/anvil.py

@@ -10,7 +10,7 @@ from mm_eth import account, rpc
 
 
 class Anvil:
-    def __init__(self, *, chain_id: int, port: int, mnemonic: str):
+    def __init__(self, *, chain_id: int, port: int, mnemonic: str) -> None:
         self.chain_id = chain_id
         self.port = port
         self.mnemonic = mnemonic
@@ -18,7 +18,7 @@ class Anvil:
 
     def start_process(self) -> None:
         cmd = f"anvil -m '{self.mnemonic}' -p {self.port} --chain-id {self.chain_id}"
-        self.process = Popen(cmd, shell=True)  # nosec
+        self.process = Popen(cmd, shell=True)  # noqa: S602 # nosec
         time.sleep(3)
 
     def stop(self) -> None:

mm_eth/cli/calcs.py

@@ -0,0 +1,112 @@
+import random
+from decimal import Decimal
+
+from loguru import logger
+from mm_std.random_ import random_decimal
+from mm_std.str import split_on_plus_minus_tokens
+
+from mm_eth.utils import from_wei_str, to_wei
+
+
+def calc_var_wei_value(value: str, *, var_name: str = "var", var_value: int | None = None, decimals: int | None = None) -> int:
+    if not isinstance(value, str):
+        raise TypeError(f"value is not str: {value}")
+    try:
+        var_name = var_name.lower()
+        result = 0
+        for token in split_on_plus_minus_tokens(value.lower()):
+            operator = token[0]
+            item = token[1:]
+            if item.isdigit():
+                item_value = int(item)
+            elif item.endswith("eth"):
+                item = item.removesuffix("eth")
+                item_value = int(Decimal(item) * 10**18)
+            elif item.endswith("ether"):
+                item = item.removesuffix("ether")
+                item_value = int(Decimal(item) * 10**18)
+            elif item.endswith("gwei"):
+                item = item.removesuffix("gwei")
+                item_value = int(Decimal(item) * 10**9)
+            elif item.endswith("t"):
+                if decimals is None:
+                    raise ValueError("t without decimals")  # noqa: TRY301
+                item = item.removesuffix("t")
+                item_value = int(Decimal(item) * 10**decimals)
+            elif item.endswith(var_name):
+                if var_value is None:
+                    raise ValueError("base value is not set")  # noqa: TRY301
+                item = item.removesuffix(var_name)
+                k = Decimal(item) if item else Decimal(1)
+                item_value = int(k * var_value)
+            elif item.startswith("random(") and item.endswith(")"):
+                item = item.lstrip("random(").rstrip(")")
+                arr = item.split(",")
+                if len(arr) != 2:
+                    raise ValueError(f"wrong value, random part: {value}")  # noqa: TRY301
+                from_value = to_wei(arr[0], decimals=decimals)
+                to_value = to_wei(arr[1], decimals=decimals)
+                if from_value > to_value:
+                    raise ValueError(f"wrong value, random part: {value}")  # noqa: TRY301
+                item_value = random.randint(from_value, to_value)
+            else:
+                raise ValueError(f"wrong value: {value}")  # noqa: TRY301
+
+            if operator == "+":
+                result += item_value
+            if operator == "-":
+                result -= item_value
+
+        return result  # noqa: TRY300
+    except Exception as err:
+        raise ValueError(f"wrong value: {value}, error={err}") from err
+
+
+def calc_decimal_value(value: str) -> Decimal:
+    value = value.lower().strip()
+    if value.startswith("random(") and value.endswith(")"):
+        arr = value.lstrip("random(").rstrip(")").split(",")
+        if len(arr) != 2:
+            raise ValueError(f"wrong value, random part: {value}")
+        from_value = Decimal(arr[0])
+        to_value = Decimal(arr[1])
+        if from_value > to_value:
+            raise ValueError(f"wrong value, random part: {value}")
+        return random_decimal(from_value, to_value)
+    return Decimal(value)
+
+
+def calc_function_args(value: str) -> str:
+    while True:
+        if "random(" not in value:
+            return value
+        start_index = value.index("random(")
+        stop_index = value.index(")", start_index)
+        random_range = [int(v.strip()) for v in value[start_index + 7 : stop_index].split(",")]
+        if len(random_range) != 2:
+            raise ValueError("wrong random(from,to) template")
+        rand_value = str(random.randint(random_range[0], random_range[1]))
+        value = value[0:start_index] + rand_value + value[stop_index + 1 :]
+
+
+def is_value_less_min_limit(
+    value_min_limit: str | None,
+    value: int,
+    value_unit: str,
+    decimals: int | None = None,
+    log_prefix: str | None = None,
+) -> bool:
+    if value_min_limit is None:
+        return False
+    if value < calc_var_wei_value(value_min_limit, decimals=decimals):
+        prefix = _get_prefix(log_prefix)
+        logger.info("{}value is less min limit, value={}", prefix, from_wei_str(value, value_unit, decimals=decimals))
+        return True
+    return False
+
+
+def _get_prefix(log_prefix: str | None) -> str:
+    prefix = log_prefix or ""
+    if prefix:
+        prefix += ": "
+    return prefix

mm_eth/cli/cli.py

@@ -0,0 +1,237 @@
+from enum import Enum
+from typing import Annotated
+
+import typer
+from mm_std import PrintFormat, print_plain
+
+from . import cli_utils
+from .cmd import (
+    balance_cmd,
+    balances_cmd,
+    call_contract_cmd,
+    config_example_cmd,
+    deploy_cmd,
+    encode_input_data_cmd,
+    mnemonic_cmd,
+    node_cmd,
+    private_key_cmd,
+    rpc_cmd,
+    send_contract_cmd,
+    solc_cmd,
+    token_cmd,
+    transfer_erc20_cmd,
+    transfer_eth_cmd,
+    vault_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)
+
+
+class ConfigExample(str, Enum):
+    TRANSFER_ETH = "transfer-eth"
+    TRANSFER_ERC20 = "transfer-erc20"
+    BALANCES = "balances"
+    CALL_CONTRACT = "call-contract"
+
+
+@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="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:
+    balance_cmd.run(rpc_url, wallet_address, token_address, wei, print_format)
+
+
+@app.command(name="token", help="Get token info")
+def token_command(
+    token_address: Annotated[str, typer.Argument()],
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL")] = "",
+) -> None:
+    token_cmd.run(rpc_url, token_address)
+
+
+@app.command(name="node", help="Check RPC url")
+def node_command(
+    urls: Annotated[list[str], typer.Argument()],
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.TABLE,
+    proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
+) -> None:
+    node_cmd.run(urls, print_format, proxy)
+
+
+@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", "-pass")] = "",
+    print_path: bool = typer.Option(False, "--print_path"),
+    path_prefix: Annotated[str, typer.Option("--path")] = "m/44'/60'/0'/0",
+    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,
+        path_prefix=path_prefix,
+        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="solc", help="Compile a solidity file")
+def solc_command(
+    contract_path: str,
+    tmp_dir: str = "/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="vault", help="Save private keys to vault")
+def vault_command(
+    keys_url: Annotated[
+        str,
+        typer.Option(..., "--url", "-u", help="Url to keys, for example https://vault.site.com:8200/v1/kv/keys1"),
+    ],
+    vault_token: Annotated[
+        str,
+        typer.Option(..., "--token", "-t", prompt=True, hide_input=True, prompt_required=False, help="A vault token"),
+    ],
+    keys_file: Annotated[str, typer.Option(..., "--file", "-f", help="Path to a file with private keys")],
+) -> None:
+    vault_cmd.run(keys_url, vault_token, keys_file)
+
+
+@app.command(name="rpc", help="Call a JSON-RPC method")
+def rpc_command(
+    method: Annotated[str, typer.Argument()] = "",
+    params: Annotated[str, typer.Argument()] = "[]",
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL", help="RPC node url")] = "",
+    hex2dec: Annotated[bool, typer.Option("--hex2dec", "-d", help="Print result in decimal value")] = False,
+) -> None:
+    rpc_cmd.run(rpc_url, method, params, hex2dec)
+
+
+@app.command(name="transfer-eth", help="Transfer eth / base token from one or many accounts")
+def transfer_eth_command(
+    config_path: str,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances 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"),
+    no_receipt: bool = typer.Option(False, "--no-receipt", "-nr", help="Don't wait for a tx receipt"),
+    debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
+) -> None:
+    transfer_eth_cmd.run(
+        config_path,
+        print_balances=print_balances,
+        print_config=print_config,
+        debug=debug,
+        no_receipt=no_receipt,
+        emulate=emulate,
+    )
+
+
+@app.command(name="transfer-erc20", help="Transfer ERC20 token from one or many accounts")
+def transfer_erc20_command(
+    config_path: str,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances 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"),
+    no_receipt: bool = typer.Option(False, "--no-receipt", "-nr", help="Don't wait for a tx receipt"),
+    debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
+) -> None:
+    transfer_erc20_cmd.run(
+        config_path,
+        print_balances=print_balances,
+        print_config=print_config,
+        debug=debug,
+        no_receipt=no_receipt,
+        emulate=emulate,
+    )
+
+
+@app.command(name="send-contract", help="Send transactions to a contract")
+def send_contract_command(
+    config_path: str,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances 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"),
+    no_receipt: bool = typer.Option(False, "--no-receipt", "-nr", help="Don't wait for a tx receipt"),
+    debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
+) -> None:
+    send_contract_cmd.run(
+        config_path,
+        print_balances=print_balances,
+        print_config=print_config,
+        debug=debug,
+        no_receipt=no_receipt,
+        emulate=emulate,
+    )
+
+
+@app.command(name="balances", help="Print base and ERC20 token balances")
+def balances_command(
+    config_path: str,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only 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:
+    balances_cmd.run(config_path, print_config, wei, nonce)
+
+
+@app.command(name="call-contract", help="Call a method on a contract")
+def call_contract_command(
+    config_path: str,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only and exit"),
+) -> None:
+    call_contract_cmd.run(config_path, print_config)
+
+
+@app.command(name="deploy", help="Deploy a smart contract onchain")
+def deploy_command(
+    config_path: str,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only and exit"),
+) -> None:
+    deploy_cmd.run(config_path, print_config=print_config)
+
+
+@app.command(name="config-example", help="Print an example of config for a command")
+def config_example_command(command: Annotated[ConfigExample, typer.Argument()]) -> None:
+    config_example_cmd.run(command)
+
+
+@app.command(name="encode-input-data", help="Encode input data by a function signature")
+def encode_input_data(
+    funtion_signature: str = typer.Argument(help="Function signature, for example: transfer(address, uint256)"),
+    args_str: str = typer.Argument(
+        help="""Function arguments, as an array string. For example: '["0xA659FB44eB5d4bFaC1074Cb426b1b11D58D28308", 123]' """,
+    ),
+) -> None:
+    encode_input_data_cmd.run(funtion_signature, args_str)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        print_plain(f"mm-eth-cli version: {cli_utils.get_version()}")
+        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/cli/cli_utils.py

@@ -0,0 +1,105 @@
+import importlib.metadata
+import sys
+from pathlib import Path
+
+import eth_utils
+from loguru import logger
+from mm_std import BaseConfig, fatal, print_json, str_to_list
+
+from mm_eth import account
+from mm_eth.account import is_private_key
+
+
+def get_version() -> str:
+    return importlib.metadata.version("mm-eth-cli")
+
+
+def public_rpc_url(url: str | None) -> str:
+    if not url or url == "1":
+        return "https://ethereum.publicnode.com"
+    if url.startswith(("http://", "https://", "ws://", "wss://")):
+        return url
+
+    match url.lower():
+        case "opbnb" | "204":
+            return "https://opbnb-mainnet-rpc.bnbchain.org"
+        case _:
+            return url
+
+
+def init_logger(debug: bool, log_debug_file: str | None, log_info_file: str | None) -> None:
+    if debug:
+        level = "DEBUG"
+        format_ = "<green>{time:YYYY-MM-DD HH:mm:ss}</green> <level>{level}</level> {message}"
+    else:
+        level = "INFO"
+        format_ = "{message}"
+
+    logger.remove()
+    logger.add(sys.stderr, format=format_, colorize=True, level=level)
+    if log_debug_file:
+        logger.add(Path(log_debug_file).expanduser(), format="{time:YYYY-MM-DD HH:mm:ss} {level} {message}")
+    if log_info_file:
+        logger.add(Path(log_info_file).expanduser(), format="{message}", level="INFO")
+
+
+def check_private_keys(addresses: list[str], private_keys: dict[str, str]) -> None:
+    for address in addresses:
+        address = address.lower()  # noqa: PLW2901
+        if address not in private_keys:
+            fatal(f"no private key for {address}")
+        if account.private_to_address(private_keys[address]) != address:
+            fatal(f"no private key for {address}")
+
+
+def load_tx_addresses_from_str(v: str | None) -> list[tuple[str, str]]:
+    result: list[tuple[str, str]] = []
+    if v is None:
+        return result
+    for line in str_to_list(v, remove_comments=True):
+        arr = line.split()
+        if len(arr) == 2 and eth_utils.is_address(arr[0]) and eth_utils.is_address(arr[1]):
+            result.append((arr[0].lower(), arr[1].lower()))
+    return result
+
+
+def load_tx_addresses_from_files(addresses_from_file: str, addresses_to_file: str) -> list[tuple[str, str]]:
+    from_file = Path(addresses_from_file).expanduser()
+    to_file = Path(addresses_to_file).expanduser()
+    if not from_file.is_file():
+        raise ValueError(f"can't read addresses from 'addresses_from_file={addresses_from_file}")
+    if not to_file.is_file():
+        raise ValueError(f"can't read addresses from 'addresses_to_file={addresses_to_file}")
+
+    # get addresses_from
+    addresses_from = []
+    for line in from_file.read_text().strip().split("\n"):
+        if not eth_utils.is_address(line):
+            raise ValueError(f"illigal address in addresses_from_file: {line}")
+        addresses_from.append(line.lower())
+
+    # get addresses_to
+    addresses_to = []
+    for line in to_file.read_text().strip().split("\n"):
+        if not eth_utils.is_address(line):
+            raise ValueError(f"illigal address in addresses_to_file: {line}")
+        addresses_to.append(line.lower())
+
+    if len(addresses_from) != len(addresses_to):
+        raise ValueError("len(addresses_from) != len(addresses_to)")
+
+    return list(zip(addresses_from, addresses_to, strict=True))
+
+
+def load_private_keys_from_file(private_keys_file: str) -> list[str]:
+    lines = Path(private_keys_file).expanduser().read_text().split()
+    return [line for line in lines if is_private_key(line)]
+
+
+def read_config[T: BaseConfig](config_type: type[T], config_path: Path) -> T:
+    res = config_type.read_config(config_path)
+    if res.is_ok():
+        return res.unwrap()
+
+    print_json(res.err)
+    sys.exit(1)

mm_eth/cli/cmd/balance_cmd.py

@@ -0,0 +1,51 @@
+from mm_std import Err, Ok, PrintFormat, fatal, print_json, print_plain
+
+from mm_eth import erc20, rpc
+from mm_eth.cli.cli_utils import public_rpc_url
+from mm_eth.utils import from_wei_str
+
+
+def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool, print_format: PrintFormat) -> None:
+    rpc_url = public_rpc_url(rpc_url)
+    json_result: dict[str, object] = {}
+
+    # nonce
+    nonce = rpc.eth_get_transaction_count(rpc_url, wallet_address).ok_or_err()
+    print_plain(f"nonce: {nonce}", print_format)
+    json_result["nonce"] = nonce
+
+    # balance
+    balance_res = rpc.eth_get_balance(rpc_url, wallet_address)
+    if isinstance(balance_res, Ok):
+        balance = str(balance_res.ok) if wei else from_wei_str(balance_res.ok, "eth")
+    else:
+        balance = balance_res.err
+    print_plain(f"eth_balance: {balance}", print_format)
+    json_result["eth_balance"] = balance
+
+    if token_address is not None:
+        # token decimal
+        decimals_res = erc20.get_decimals(rpc_url, token_address)
+        if isinstance(decimals_res, Err):
+            fatal(f"error: can't get token decimals: {decimals_res.err}")
+        decimals = decimals_res.ok
+        print_plain(f"token_decimal: {decimals}", print_format)
+        json_result["token_decimal"] = decimals
+
+        # token symbol
+        symbol_res = erc20.get_symbol(rpc_url, token_address)
+        if isinstance(symbol_res, Err):
+            fatal(f"error: can't get token symbol: {symbol_res.err}")
+        symbol = symbol_res.ok
+        print_plain(f"token_symbol: {symbol}", print_format)
+        json_result["token_symbol"] = symbol
+
+        # token balance
+        balance_res = erc20.get_balance(rpc_url, token_address, wallet_address)
+        if isinstance(balance_res, Err):
+            fatal(f"error: can't get token balance: {balance_res.err}")
+        balance = str(balance_res.ok) if wei else from_wei_str(balance_res.ok, "t", decimals=decimals)
+        print_plain(f"token_balance: {balance}", print_format)
+        json_result["token_balance"] = balance
+
+    print_json(json_result, print_format)

mm_eth/cli/cmd/balances_cmd.py

@@ -0,0 +1,124 @@
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from mm_std import BaseConfig, Err, Ok, fatal, print_json
+from pydantic import Field, field_validator
+from rich.live import Live
+from rich.table import Table
+
+from mm_eth import erc20, rpc
+from mm_eth.cli import cli_utils, validators
+from mm_eth.utils import from_token_wei_str, from_wei_str
+
+
+class Config(BaseConfig):
+    addresses: list[str]
+    tokens: list[str] = Field(default_factory=list)
+    nodes: list[str]
+    round_ndigits: int = 5
+
+    @field_validator("nodes", mode="before")
+    @classmethod
+    def nodes_validator(cls, v: str | list[str] | None) -> list[str]:
+        return validators.nodes_validator(v)
+
+    @field_validator("tokens", "addresses", mode="before")
+    @classmethod
+    def addresses_validator(cls, v: str | list[str] | None) -> list[str]:
+        return validators.addresses_validator(v)
+
+
+@dataclass
+class Token:
+    address: str
+    decimals: int
+    symbol: str
+
+
+def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> None:
+    config = cli_utils.read_config(Config, Path(config_path))
+    if print_config:
+        print_json(config.model_dump())
+        sys.exit(0)
+
+    tokens = _get_tokens_info(config)
+
+    table = Table(title="balances")
+    table.add_column("address")
+    if show_nonce:
+        table.add_column("nonce")
+    table.add_column("wei" if 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 show_nonce:
+                row.append(str(rpc.eth_get_transaction_count(config.nodes, address, attempts=5).ok_or_err()))
+
+            base_balance_res = rpc.eth_get_balance(config.nodes, address, attempts=5)
+            if isinstance(base_balance_res, Ok):
+                base_sum += base_balance_res.ok
+                if wei:
+                    row.append(str(base_balance_res.ok))
+                else:
+                    row.append(
+                        from_wei_str(base_balance_res.ok, "eth", round_ndigits=config.round_ndigits, print_unit_name=False),
+                    )
+            else:
+                row.append(base_balance_res.err)
+
+            for t in tokens:
+                token_balance_res = erc20.get_balance(config.nodes, t.address, address, attempts=5)
+                if isinstance(token_balance_res, Ok):
+                    token_sum[t.address] += token_balance_res.ok
+                    if wei:
+                        row.append(str(token_balance_res.ok))
+                    else:
+                        row.append(
+                            from_token_wei_str(
+                                token_balance_res.ok,
+                                decimals=t.decimals,
+                                round_ndigits=config.round_ndigits,
+                            ),
+                        )
+                else:
+                    row.append(token_balance_res.err)
+
+            table.add_row(*row)
+
+        sum_row = ["sum"]
+        if show_nonce:
+            sum_row.append("")
+        if wei:
+            sum_row.append(str(base_sum))
+            sum_row.extend([str(token_sum[t.address]) for t in tokens])
+        else:
+            sum_row.append(from_wei_str(base_sum, "eth", round_ndigits=config.round_ndigits, print_unit_name=False))
+            sum_row.extend(
+                [from_token_wei_str(token_sum[t.address], t.decimals, round_ndigits=config.round_ndigits) for t in tokens]
+            )
+
+        table.add_row(*sum_row)
+
+
+def _get_tokens_info(config: Config) -> list[Token]:
+    result: list[Token] = []
+    for address in config.tokens:
+        decimals_res = erc20.get_decimals(config.nodes, address, attempts=5)
+        if isinstance(decimals_res, Err):
+            fatal(f"can't get token {address} decimals: {decimals_res.err}")
+        decimal = decimals_res.ok
+
+        symbols_res = erc20.get_symbol(config.nodes, address, attempts=5)
+        if isinstance(symbols_res, Err):
+            fatal(f"can't get token {address} symbol: {symbols_res.err}")
+        symbol = symbols_res.ok
+
+        result.append(Token(address=address, decimals=decimal, symbol=symbol))
+
+    return result