mm-eth 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

mm_eth/account.py

@@ -3,6 +3,7 @@ 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 eth_typing import ChecksumAddress
@@ -39,13 +40,17 @@ def generate_accounts(  # nosec
     for i in range(limit):
         path = f"{path_prefix}/{i}"
         acc = Account.from_mnemonic(mnemonic=mnemonic, account_path=path, passphrase=passphrase)
-        private_key = acc.key.hex().lower()
-        if not private_key.startswith("0x"):
-            private_key = f"0x{private_key}"
+        private_key = acc.key.to_0x_hex().lower()
         result.append(NewAccount(path, acc.address, private_key))
     return result
 
 
+def address_from_private(private_key: str) -> str:
+    """returns address in lower case"""
+    acc: LocalAccount = Account.from_key(private_key)
+    return acc.address.lower()
+
+
 def private_to_address(private_key: str) -> str | None:
     """returns address in lower case"""
     try:
@@ -54,19 +59,13 @@ def private_to_address(private_key: str) -> str | None:
         return None
 
 
-def create_private_keys_dict(private_keys: list[str]) -> dict[str, str]:  # address in lower
-    result = {}
-    for private_key in private_keys:
-        address = private_to_address(private_key)
-        if address is None:
-            raise ValueError("wrong private key")
-        result[address.lower()] = private_key
-    return result
-
-
 def is_private_key(private_key: str) -> bool:
     try:
         key_api.PrivateKey(decode_hex(private_key)).public_key.to_address()
         return True  # noqa: TRY300
     except Exception:
         return False
+
+
+def is_address(address: str) -> bool:
+    return eth_utils.is_address(address)

mm_eth/cli/calcs.py

@@ -1,79 +1,67 @@
 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
+import mm_crypto_utils
+from mm_crypto_utils import VarInt
 
-from mm_eth.utils import from_wei_str, to_wei
+from mm_eth.constants import SUFFIX_DECIMALS
 
 
-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
+def calc_eth_expression(expression: str, var: VarInt | None = None) -> int:
+    return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals=SUFFIX_DECIMALS)
 
-            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_var_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")
+#                 item = item.removesuffix("t")
+#                 item_value = int(Decimal(item) * 10**decimals)
+#             elif item.endswith(var_name):
+#                 if var_value is None:
+#                     raise ValueError("var_value is not set")
+#                 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}")
+#                 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}")
+#                 item_value = random.randint(from_value, to_value)
+#             else:
+#                 raise ValueError(f"wrong value: {value}")
+#
+#             if operator == "+":
+#                 result += item_value
+#             if operator == "-":
+#                 result -= item_value
+#
+#         return result
+#     except Exception as err:
+#         raise ValueError(f"illegal ee: {value}, error={err}") from err
 
 
 def calc_function_args(value: str) -> str:
@@ -89,24 +77,17 @@ def calc_function_args(value: str) -> str:
         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
+# 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_eth_expression(value_min_limit):
+#         prefix = get_log_prefix(log_prefix)
+#         logger.info("{}value is less min limit, value={}", prefix, from_wei_str(value, value_unit, decimals=decimals))
+#         return True
+#     return False

mm_eth/cli/cli.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from pathlib import Path
 from typing import Annotated
 
 import typer
@@ -21,8 +22,15 @@ from .cmd import (
     token_cmd,
     transfer_erc20_cmd,
     transfer_eth_cmd,
+    tx_cmd,
     vault_cmd,
 )
+from .cmd.balances_cmd import BalancesCmdParams
+from .cmd.call_contract_cmd import CallContractCmdParams
+from .cmd.deploy_cmd import DeployCmdParams
+from .cmd.send_contract_cmd import SendContractCmdParams
+from .cmd.transfer_erc20_cmd import TransferErc20CmdParams
+from .cmd.transfer_eth_cmd import TransferEthCmdParams
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
@@ -42,7 +50,7 @@ class ConfigExample(str, Enum):
 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
+    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:
@@ -52,7 +60,7 @@ def balance_command(
 @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")] = "",
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL")] = "",
 ) -> None:
     token_cmd.run(rpc_url, token_address)
 
@@ -109,7 +117,7 @@ def vault_command(
         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")],
+    keys_file: Annotated[Path, typer.Option(..., "--file", "-f", help="Path to a file with private keys")],
 ) -> None:
     vault_cmd.run(keys_url, vault_token, keys_file)
 
@@ -118,15 +126,24 @@ def vault_command(
 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")] = "",
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_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="tx", help="Get transaction info by hash")
+def tx_command(
+    tx_hash: Annotated[str, typer.Argument()],
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL", help="RPC node url")] = "",
+    get_receipt: Annotated[bool, typer.Option("--receipt", "-r", help="Get receipt")] = False,
+) -> None:
+    tx_cmd.run(rpc_url, tx_hash, get_receipt)
+
+
 @app.command(name="transfer-eth", help="Transfer eth / base token from one or many accounts")
 def transfer_eth_command(
-    config_path: str,
+    config_path: Path,
     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"),
@@ -134,18 +151,20 @@ def transfer_eth_command(
     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,
+        TransferEthCmdParams(
+            config_path=config_path,
+            print_balances=print_balances,
+            print_config_and_exit=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,
+    config_path: Path,
     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"),
@@ -153,18 +172,20 @@ def transfer_erc20_command(
     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,
+        TransferErc20CmdParams(
+            config_path=config_path,
+            print_balances=print_balances,
+            print_config_and_exit=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,
+    config_path: Path,
     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"),
@@ -172,39 +193,41 @@ def send_contract_command(
     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,
+        SendContractCmdParams(
+            config_path=config_path,
+            print_balances=print_balances,
+            print_config_and_exit=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"),
+    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:
-    balances_cmd.run(config_path, print_config, wei, nonce)
+    balances_cmd.run(BalancesCmdParams(config_path=config_path, print_config_and_exit=print_config, wei=wei, show_nonce=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"),
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
 ) -> None:
-    call_contract_cmd.run(config_path, print_config)
+    call_contract_cmd.run(CallContractCmdParams(config_path=config_path, print_config_and_exit=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"),
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
 ) -> None:
-    deploy_cmd.run(config_path, print_config=print_config)
+    deploy_cmd.run(DeployCmdParams(config_path=config_path, print_config_and_exit=print_config))
 
 
 @app.command(name="config-example", help="Print an example of config for a command")
@@ -214,17 +237,17 @@ def config_example_command(command: Annotated[ConfigExample, typer.Argument()])
 
 @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)"),
+    function_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)
+    encode_input_data_cmd.run(function_signature, args_str)
 
 
 def version_callback(value: bool) -> None:
     if value:
-        print_plain(f"mm-eth-cli version: {cli_utils.get_version()}")
+        print_plain(f"mm-eth: {cli_utils.get_version()}")
         raise typer.Exit
 
 

mm_eth/cli/cli_utils.py

@@ -1,17 +1,11 @@
 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
+from pydantic import BaseModel
 
 
 def get_version() -> str:
-    return importlib.metadata.version("mm-eth-cli")
+    return importlib.metadata.version("mm-eth")
 
 
 def public_rpc_url(url: str | None) -> str:
@@ -21,82 +15,18 @@ def public_rpc_url(url: str | None) -> str:
         return url
 
     match url.lower():
+        case "mainnet" | "1":
+            return "https://ethereum.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
 
 
-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 print_config_and_exit(exit_: bool, config: BaseConfig, exclude: set[str] | None = None) -> None:
-    if exit_:
-        print_json(config.model_dump(exclude=exclude))
-        sys.exit(0)
+class BaseConfigParams(BaseModel):
+    config_path: Path
+    print_config_and_exit: bool

mm_eth/cli/cmd/balance_cmd.py

@@ -48,4 +48,4 @@ def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool,
         print_plain(f"token_balance: {balance}", print_format)
         json_result["token_balance"] = balance
 
-    print_json(json_result, print_format)
+    print_json(json_result, print_format=print_format)

mm_eth/cli/cmd/balances_cmd.py

@@ -1,29 +1,23 @@
 from dataclasses import dataclass
+from typing import Annotated
 
 from mm_std import BaseConfig, Err, Ok, fatal
-from pydantic import Field, field_validator
+from pydantic import BeforeValidator
 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.cli.cli_utils import BaseConfigParams
+from mm_eth.cli.validators import 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]
+    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
 
-    @field_validator("nodes", mode="before")
-    def nodes_validator(cls, v: str | list[str] | None) -> list[str]:
-        return validators.nodes_validator(v)
-
-    @field_validator("tokens", "addresses", mode="before")
-    def addresses_validator(cls, v: str | list[str] | None) -> list[str]:
-        return validators.addresses_validator(v)
-
 
 @dataclass
 class Token:
@@ -32,17 +26,23 @@ class Token:
     symbol: str
 
 
-def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> None:
-    config = Config.read_config_or_exit(config_path)
-    cli_utils.print_config_and_exit(print_config, config)
+class BalancesCmdParams(BaseConfigParams):
+    wei: bool
+    show_nonce: bool
+
+
+def run(params: BalancesCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(params.config_path)
+    if params.print_config_and_exit:
+        config.print_and_exit()
 
     tokens = _get_tokens_info(config)
 
     table = Table(title="balances")
     table.add_column("address")
-    if show_nonce:
+    if params.show_nonce:
         table.add_column("nonce")
-    table.add_column("wei" if wei else "eth")
+    table.add_column("wei" if params.wei else "eth")
     for t in tokens:
         table.add_column(t.symbol)
 
@@ -51,13 +51,13 @@ def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> No
     with Live(table, refresh_per_second=0.5):
         for address in config.addresses:
             row = [address]
-            if show_nonce:
+            if params.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:
+                if params.wei:
                     row.append(str(base_balance_res.ok))
                 else:
                     row.append(
@@ -70,7 +70,7 @@ def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> No
                 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:
+                    if params.wei:
                         row.append(str(token_balance_res.ok))
                     else:
                         row.append(
@@ -86,9 +86,9 @@ def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> No
             table.add_row(*row)
 
         sum_row = ["sum"]
-        if show_nonce:
+        if params.show_nonce:
             sum_row.append("")
-        if wei:
+        if params.wei:
             sum_row.append(str(base_sum))
             sum_row.extend([str(token_sum[t.address]) for t in tokens])
         else: