mm-eth 0.3.1__tar.gz → 0.4.0__tar.gz

{mm_eth-0.3.1 → mm_eth-0.4.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: mm-eth
-Version: 0.3.1
+Version: 0.4.0
 Requires-Python: >=3.12
-Requires-Dist: mm-crypto-utils>=0.1.4
+Requires-Dist: mm-crypto-utils>=0.1.5
 Requires-Dist: typer>=0.15.1
-Requires-Dist: web3~=7.7.0
+Requires-Dist: web3~=7.8.0
 Requires-Dist: websocket-client~=1.8.0

{mm_eth-0.3.1 → mm_eth-0.4.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "mm-eth"
-version = "0.3.1"
+version = "0.4.0"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
-    "mm-crypto-utils>=0.1.4",
+    "mm-crypto-utils>=0.1.5",
     "websocket-client~=1.8.0",
-    "web3~=7.7.0",
+    "web3~=7.8.0",
     "typer>=0.15.1",
 ]
 [project.scripts]
@@ -20,11 +20,11 @@ build-backend = "hatchling.build"
 dev-dependencies = [
     "pytest~=8.3.4",
     "pytest-xdist~=3.6.1",
-    "ruff~=0.9.4",
+    "ruff~=0.9.5",
     "pip-audit~=2.7.3",
     "bandit~=1.8.2",
-    "mypy~=1.14.1",
-    "types-PyYAML~=6.0.12.20241230",
+    "mypy~=1.15.0",
+    "types-pyyaml>=6.0.12.20241230",
 ]
 
 [tool.mypy]

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

@@ -0,0 +1,27 @@
+import random
+
+import mm_crypto_utils
+from mm_crypto_utils import VarInt
+
+from mm_eth.constants import SUFFIX_DECIMALS
+
+
+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)
+
+
+def calc_token_expression(expression: str, token_decimals: int, var: VarInt | None = None) -> int:
+    return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals={"t": token_decimals})
+
+
+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 :]

{mm_eth-0.3.1 → mm_eth-0.4.0}/src/mm_eth/cli/cli.py

@@ -10,9 +10,9 @@ from .cmd import (
     balance_cmd,
     balances_cmd,
     call_contract_cmd,
-    config_example_cmd,
     deploy_cmd,
     encode_input_data_cmd,
+    example_cmd,
     mnemonic_cmd,
     node_cmd,
     private_key_cmd,
@@ -20,8 +20,7 @@ from .cmd import (
     send_contract_cmd,
     solc_cmd,
     token_cmd,
-    transfer_erc20_cmd,
-    transfer_eth_cmd,
+    transfer_cmd,
     tx_cmd,
     vault_cmd,
 )
@@ -29,8 +28,7 @@ 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
+from .cmd.transfer_cmd import TransferCmdParams
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
@@ -40,8 +38,7 @@ app.add_typer(wallet_app, name="w", hidden=True)
 
 
 class ConfigExample(str, Enum):
-    TRANSFER_ETH = "transfer-eth"
-    TRANSFER_ERC20 = "transfer-erc20"
+    TRANSFER = "transfer"
     BALANCES = "balances"
     CALL_CONTRACT = "call-contract"
 
@@ -141,43 +138,24 @@ def tx_command(
     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: 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"),
-    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(
-        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(
+@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_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"),
+    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:
-    transfer_erc20_cmd.run(
-        TransferErc20CmdParams(
+    transfer_cmd.run(
+        TransferCmdParams(
             config_path=config_path,
             print_balances=print_balances,
-            print_config_and_exit=print_config,
+            print_config=print_config,
             debug=debug,
-            no_receipt=no_receipt,
+            skip_receipt=skip_receipt,
             emulate=emulate,
         )
     )
@@ -196,7 +174,7 @@ def send_contract_command(
         SendContractCmdParams(
             config_path=config_path,
             print_balances=print_balances,
-            print_config_and_exit=print_config,
+            print_config=print_config,
             debug=debug,
             no_receipt=no_receipt,
             emulate=emulate,
@@ -211,7 +189,7 @@ def balances_command(
     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(BalancesCmdParams(config_path=config_path, print_config_and_exit=print_config, wei=wei, show_nonce=nonce))
+    balances_cmd.run(BalancesCmdParams(config_path=config_path, print_config=print_config, wei=wei, show_nonce=nonce))
 
 
 @app.command(name="call-contract", help="Call a method on a contract")
@@ -219,7 +197,7 @@ def call_contract_command(
     config_path: Path,
     print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
 ) -> None:
-    call_contract_cmd.run(CallContractCmdParams(config_path=config_path, print_config_and_exit=print_config))
+    call_contract_cmd.run(CallContractCmdParams(config_path=config_path, print_config=print_config))
 
 
 @app.command(name="deploy", help="Deploy a smart contract onchain")
@@ -227,12 +205,12 @@ def deploy_command(
     config_path: Path,
     print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
 ) -> None:
-    deploy_cmd.run(DeployCmdParams(config_path=config_path, print_config_and_exit=print_config))
+    deploy_cmd.run(DeployCmdParams(config_path=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="example", help="Displays an example configuration for a command")
+def example_command(command: Annotated[ConfigExample, typer.Argument()]) -> None:
+    example_cmd.run(command)
 
 
 @app.command(name="encode-input-data", help="Encode input data by a function signature")

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

@@ -0,0 +1,60 @@
+import importlib.metadata
+import time
+from pathlib import Path
+from typing import Literal
+
+from mm_crypto_utils import Nodes, Proxies
+from mm_std import BaseConfig, print_json
+from pydantic import BaseModel
+
+from mm_eth import rpc
+
+
+def get_version() -> str:
+    return importlib.metadata.version("mm-eth")
+
+
+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 "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
+
+
+class BaseConfigParams(BaseModel):
+    config_path: Path
+    print_config: bool
+
+
+def print_config(config: BaseConfig, exclude: set[str] | None = None, count: set[str] | None = None) -> None:
+    data = config.model_dump(exclude=exclude)
+    if count:
+        for k in count:
+            data[k] = len(data[k])
+    print_json(data)
+
+
+def wait_tx_status(nodes: Nodes, proxies: Proxies, tx_hash: str, timeout: int) -> Literal["OK", "FAIL", "TIMEOUT"]:
+    started_at = time.perf_counter()
+    count = 0
+    while True:
+        res = rpc.get_tx_status(nodes, tx_hash, proxies=proxies, attempts=5)
+        if res.is_ok():
+            return "OK" if res.ok == 1 else "FAIL"
+
+        time.sleep(1)
+        count += 1
+        if time.perf_counter() - started_at > timeout:
+            return "TIMEOUT"

{mm_eth-0.3.1 → mm_eth-0.4.0}/src/mm_eth/cli/cmd/balances_cmd.py

@@ -33,7 +33,7 @@ class BalancesCmdParams(BaseConfigParams):
 
 def run(params: BalancesCmdParams) -> None:
     config = Config.read_toml_config_or_exit(params.config_path)
-    if params.print_config_and_exit:
+    if params.print_config:
         config.print_and_exit()
 
     tokens = _get_tokens_info(config)

{mm_eth-0.3.1 → mm_eth-0.4.0}/src/mm_eth/cli/cmd/call_contract_cmd.py

@@ -22,7 +22,7 @@ class CallContractCmdParams(BaseConfigParams):
 
 def run(cli_params: CallContractCmdParams) -> None:
     config = Config.read_toml_config_or_exit(cli_params.config_path)
-    if cli_params.print_config_and_exit:
+    if cli_params.print_config:
         config.print_and_exit()
 
     input_data = abi.encode_function_input_by_signature(

{mm_eth-0.3.1 → mm_eth-0.4.0}/src/mm_eth/cli/cmd/deploy_cmd.py

@@ -27,7 +27,7 @@ class DeployCmdParams(BaseConfigParams):
 
 def run(cli_params: DeployCmdParams) -> None:
     config = Config.read_toml_config_or_exit(cli_params.config_path)
-    if cli_params.print_config_and_exit:
+    if cli_params.print_config:
         config.print_and_exit({"private_key"})
 
     constructor_types = yaml.full_load(config.constructor_types)

mm_eth-0.3.1/src/mm_eth/cli/cmd/config_example_cmd.py → mm_eth-0.4.0/src/mm_eth/cli/cmd/example_cmd.py

@@ -5,5 +5,5 @@ from mm_std import print_plain
 
 def run(command: str) -> None:
     command = command.replace("-", "_")
-    example_file = Path(Path(__file__).parent.absolute(), "../config_examples", f"{command}.toml")
+    example_file = Path(Path(__file__).parent.absolute(), "../examples", f"{command}.toml")
     print_plain(example_file.read_text())

{mm_eth-0.3.1 → mm_eth-0.4.0}/src/mm_eth/cli/cmd/send_contract_cmd.py

@@ -65,7 +65,7 @@ class SendContractCmdParams(BaseConfigParams):
 # noinspection DuplicatedCode
 def run(cli_params: SendContractCmdParams) -> None:
     config = Config.read_toml_config_or_exit(cli_params.config_path)
-    if cli_params.print_config_and_exit:
+    if cli_params.print_config:
         config.print_and_exit({"private_key"})
 
     mm_crypto_utils.init_logger(cli_params.debug, config.log_debug, config.log_info)

mm_eth-0.4.0/src/mm_eth/cli/cmd/transfer_cmd.py

@@ -0,0 +1,311 @@
+import sys
+import time
+from pathlib import Path
+from typing import Annotated, Self
+
+import mm_crypto_utils
+from loguru import logger
+from mm_crypto_utils import AddressToPrivate, TxRoute
+from mm_std import BaseConfig, Err, fatal, utc_now
+from pydantic import AfterValidator, BeforeValidator, Field, model_validator
+from rich.live import Live
+from rich.table import Table
+
+from mm_eth import erc20, rpc
+from mm_eth.cli import calcs, cli_utils, rpc_helpers
+from mm_eth.cli.calcs import calc_eth_expression
+from mm_eth.cli.cli_utils import BaseConfigParams
+from mm_eth.cli.validators import Validators
+from mm_eth.tx import sign_tx
+from mm_eth.utils import from_wei_str
+
+
+class Config(BaseConfig):
+    nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
+    chain_id: int
+    routes: Annotated[list[TxRoute], BeforeValidator(Validators.eth_routes())]
+    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.eth_private_keys())]
+    token: Annotated[str | None, AfterValidator(Validators.eth_address())] = None  # if None, then eth transfer
+    token_decimals: int = -1
+    max_fee: Annotated[str, AfterValidator(Validators.valid_eth_expression("base_fee"))]
+    priority_fee: Annotated[str, AfterValidator(Validators.valid_eth_expression())]
+    max_fee_limit: Annotated[str | None, AfterValidator(Validators.valid_eth_expression())] = None
+    value: Annotated[str, AfterValidator(Validators.valid_eth_or_token_expression("balance"))]
+    value_min_limit: Annotated[str | None, AfterValidator(Validators.valid_eth_or_token_expression())] = None
+    gas: Annotated[str, AfterValidator(Validators.valid_eth_expression("estimate"))]
+    delay: Annotated[str | None, AfterValidator(Validators.valid_calc_decimal_value())] = None  # in seconds
+    round_ndigits: int = 5
+    proxies: Annotated[list[str], Field(default_factory=list), BeforeValidator(Validators.proxies())]
+    wait_tx_timeout: int = 120
+    log_debug: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
+    log_info: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
+
+    @property
+    def from_addresses(self) -> list[str]:
+        return [r.from_address for r in self.routes]
+
+    @model_validator(mode="after")
+    def final_validator(self) -> Self:
+        if not self.private_keys.contains_all_addresses(self.from_addresses):
+            raise ValueError("private keys are not set for all addresses")
+
+        if self.token:
+            Validators.valid_token_expression("balance")(self.value)
+            if self.value_min_limit:
+                Validators.valid_token_expression()(self.value_min_limit)
+        else:
+            Validators.valid_eth_expression("balance")(self.value)
+            if self.value_min_limit:
+                Validators.valid_eth_expression()(self.value_min_limit)
+
+        if self.token:
+            res = erc20.get_decimals(self.nodes, self.token, proxies=self.proxies, attempts=5)
+            if isinstance(res, Err):
+                fatal(f"can't get token decimals: {res.err}")
+            self.token_decimals = res.ok
+
+        return self
+
+
+class TransferCmdParams(BaseConfigParams):
+    print_balances: bool
+    debug: bool
+    skip_receipt: bool
+    emulate: bool
+
+
+def run(cmd_params: TransferCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(cmd_params.config_path)
+    if cmd_params.print_config:
+        cli_utils.print_config(config, exclude={"private_keys"}, count=None if cmd_params.debug else {"proxies"})
+        sys.exit(0)
+
+    rpc_helpers.check_nodes_for_chain_id(config.nodes, config.chain_id)
+
+    if cmd_params.print_balances:
+        _print_balances(config)
+        sys.exit(0)
+
+    _run_transfers(config, cmd_params)
+
+
+def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
+    mm_crypto_utils.init_logger(cmd_params.debug, config.log_debug, config.log_info)
+    logger.info(f"transfer {cmd_params.config_path}: started at {utc_now()} UTC")
+    logger.debug(f"config={config.model_dump(exclude={'private_keys'}) | {'version': cli_utils.get_version()}}")
+    for i, route in enumerate(config.routes):
+        _transfer(route, config, cmd_params)
+        if config.delay is not None and i < len(config.routes) - 1:
+            delay_value = mm_crypto_utils.calc_decimal_value(config.delay)
+            logger.info(f"delay {delay_value} seconds")
+            if not cmd_params.emulate:
+                time.sleep(float(delay_value))
+    logger.info(f"finished at {utc_now()} UTC")
+
+
+def _transfer(route: TxRoute, config: Config, cmd_params: TransferCmdParams) -> None:
+    nonce = rpc_helpers.get_nonce(config.nodes, route.from_address, route.log_prefix)
+    if nonce is None:
+        return
+
+    max_fee = rpc_helpers.calc_max_fee(config.nodes, config.max_fee, route.log_prefix)
+    if max_fee is None:
+        return
+
+    if rpc_helpers.is_max_fee_limit_exceeded(max_fee, config.max_fee_limit, route.log_prefix):
+        return
+
+    gas = _calc_gas(route, config)
+    if gas is None:
+        return
+
+    value = _calc_value(route, max_fee=max_fee, gas=gas, config=config)
+    if value is None:
+        return
+
+    if not _check_value_min_limit(route, value, config):
+        return
+
+    priority_fee = calc_eth_expression(config.priority_fee)
+
+    # emulate?
+    if cmd_params.emulate:
+        msg = f"{route.log_prefix}: emulate,"
+        msg += f" value={_value_with_suffix(value, config)},"
+        msg += f" max_fee={from_wei_str(max_fee, 'gwei', config.round_ndigits)},"
+        msg += f" priority_fee={from_wei_str(priority_fee, 'gwei', config.round_ndigits)},"
+        msg += f" gas={gas}"
+        logger.info(msg)
+        return
+
+    tx_hash = _send_tx(route=route, nonce=nonce, max_fee=max_fee, priority_fee=priority_fee, gas=gas, value=value, config=config)
+    if tx_hash is None:
+        return
+
+    status = "UNKNOWN"
+    if not cmd_params.skip_receipt:
+        logger.debug(f"{route.log_prefix}: waiting for receipt, tx_hash={tx_hash}")
+        status = cli_utils.wait_tx_status(config.nodes, config.proxies, tx_hash, config.wait_tx_timeout)
+
+    logger.info(f"{route.log_prefix}: tx_hash={tx_hash}, value={_value_with_suffix(value, config)},  status={status}")
+
+
+def _calc_value(route: TxRoute, max_fee: int, gas: int, config: Config) -> int | None:
+    if config.token:
+        return rpc_helpers.calc_erc20_value_for_address(
+            nodes=config.nodes,
+            value_expression=config.value,
+            wallet_address=route.from_address,
+            token_address=config.token,
+            decimals=config.token_decimals,
+            log_prefix=route.log_prefix,
+        )
+    return rpc_helpers.calc_eth_value_for_address(
+        nodes=config.nodes,
+        value_expression=config.value,
+        address=route.from_address,
+        gas=gas,
+        max_fee=max_fee,
+        log_prefix=route.log_prefix,
+    )
+
+
+def _check_value_min_limit(route: TxRoute, value: int, config: Config) -> bool:
+    """Returns False if the transfer should be skipped."""
+    if config.value_min_limit:
+        if config.token:
+            value_min_limit = calcs.calc_token_expression(config.value_min_limit, config.token_decimals)
+        else:
+            value_min_limit = calcs.calc_eth_expression(config.value_min_limit)
+        if value < value_min_limit:
+            logger.info(f"{route.log_prefix}: value<value_min_limit, value={_value_with_suffix(value, config)}")
+    return True
+
+
+def _send_tx(*, route: TxRoute, nonce: int, max_fee: int, priority_fee: int, gas: int, value: int, config: Config) -> str | None:
+    debug_tx_params = {
+        "nonce": nonce,
+        "max_fee": max_fee,
+        "priority_fee": priority_fee,
+        "gas": gas,
+        "value": value,
+        "to": route.to_address,
+        "chain_id": config.chain_id,
+    }
+    logger.debug(f"{route.log_prefix}: tx_params={debug_tx_params}")
+
+    if config.token:
+        signed_tx = erc20.sign_transfer_tx(
+            nonce=nonce,
+            max_fee_per_gas=max_fee,
+            max_priority_fee_per_gas=priority_fee,
+            gas_limit=gas,
+            private_key=config.private_keys[route.from_address],
+            chain_id=config.chain_id,
+            value=value,
+            token_address=config.token,
+            recipient_address=route.to_address,
+        )
+    else:
+        signed_tx = sign_tx(
+            nonce=nonce,
+            max_fee_per_gas=max_fee,
+            max_priority_fee_per_gas=priority_fee,
+            gas=gas,
+            private_key=config.private_keys[route.from_address],
+            chain_id=config.chain_id,
+            value=value,
+            to=route.to_address,
+        )
+    res = rpc.eth_send_raw_transaction(config.nodes, signed_tx.raw_tx, attempts=5)
+    if isinstance(res, Err):
+        logger.info(f"{route.log_prefix}: tx error {res.err}")
+        return None
+    return res.ok
+
+
+def _calc_gas(route: TxRoute, config: Config) -> int | None:
+    if config.token:
+        return rpc_helpers.calc_gas(
+            nodes=config.nodes,
+            gas_expression=config.gas,
+            from_address=route.from_address,
+            to_address=config.token,
+            data=erc20.encode_transfer_input_data(route.to_address, 1234),
+            log_prefix=route.log_prefix,
+        )
+    return rpc_helpers.calc_gas(
+        nodes=config.nodes,
+        gas_expression=config.gas,
+        from_address=route.from_address,
+        to_address=route.to_address,
+        value=123,
+        log_prefix=route.log_prefix,
+    )
+
+
+def _print_balances(config: Config) -> None:
+    if config.token:
+        headers = ["n", "from_address", "nonce", "eth", "t", "to_address", "nonce", "eth", "t"]
+    else:
+        headers = ["n", "from_address", "nonce", "eth", "to_address", "nonce", "eth"]
+    table = Table(*headers, title="balances")
+    with Live(table, refresh_per_second=0.5):
+        for count, route in enumerate(config.routes):
+            from_nonce = _get_nonce_str(route.from_address, config)
+            to_nonce = _get_nonce_str(route.to_address, config)
+
+            from_eth_balance = _get_eth_balance_str(route.from_address, config)
+            to_eth_balance = _get_eth_balance_str(route.to_address, config)
+
+            from_token_balance = _get_token_balance_str(route.from_address, config) if config.token else ""
+            to_token_balance = _get_token_balance_str(route.to_address, config) if config.token else ""
+
+            if config.token:
+                table.add_row(
+                    str(count),
+                    route.from_address,
+                    from_nonce,
+                    from_eth_balance,
+                    from_token_balance,
+                    route.to_address,
+                    to_nonce,
+                    to_eth_balance,
+                    to_token_balance,
+                )
+            else:
+                table.add_row(
+                    str(count),
+                    route.from_address,
+                    from_nonce,
+                    from_eth_balance,
+                    route.to_address,
+                    to_nonce,
+                    to_eth_balance,
+                )
+
+
+def _get_nonce_str(address: str, config: Config) -> str:
+    return str(rpc.eth_get_transaction_count(config.nodes, address, proxies=config.proxies, attempts=5).ok_or_err())
+
+
+def _get_eth_balance_str(address: str, config: Config) -> str:
+    return rpc.eth_get_balance(config.nodes, address, proxies=config.proxies, attempts=5).map_or_else(
+        lambda err: err,
+        lambda ok: from_wei_str(ok, "eth", config.round_ndigits),
+    )
+
+
+def _get_token_balance_str(address: str, config: Config) -> str:
+    if not config.token:
+        raise ValueError("token is not set")
+    return erc20.get_balance(config.nodes, config.token, address, proxies=config.proxies, attempts=5).map_or_else(
+        lambda err: err,
+        lambda ok: from_wei_str(ok, "t", decimals=config.token_decimals, round_ndigits=config.round_ndigits),
+    )
+
+
+def _value_with_suffix(value: int, config: Config) -> str:
+    if config.token:
+        return from_wei_str(value, "t", config.round_ndigits, decimals=config.token_decimals)
+    return from_wei_str(value, "eth", config.round_ndigits)

{mm_eth-0.3.1/src/mm_eth/cli/config_examples → mm_eth-0.4.0/src/mm_eth/cli/examples}/balances.toml

@@ -3,13 +3,16 @@ addresses = """
   0x58487485c3858109f5A37e42546FE87473f79a4b
   0x97C77B548aE0d4925F5C201220fC6d8996424309
 """
+
 tokens = """
   0x7EdF3b8579c21A8820b4C0B8352541c1CE04045f # USDT
   0x6a55fe4884DE7E1d904BdC47A3BA092240ae9B39 # USDC
 """
+
 nodes = """
   https://arb1.arbitrum.io/rpc
   https://rpc.arb1.arbitrum.gateway.fm
   https://arbitrum-one.publicnode.com
 """
+
 round_ndigits = 3

{mm_eth-0.3.1/src/mm_eth/cli/config_examples → mm_eth-0.4.0/src/mm_eth/cli/examples}/call_contract.toml

@@ -1,5 +1,9 @@
 contract_address = "0xBa985cad26658EB00eA42aCc7516aed52e7a8AcC"
+
 function_signature = "balanceOf(address)"
+
 function_args = "['0x83aC43147BA5dAA5abc4ccEA84F2B8000bA82f26']"
+
 outputs_types = "uint256" # optional
+
 node = "https://rpc.eth.gateway.fm"