mm-eth 0.5.17__py3-none-any.whl → 0.6.1__py3-none-any.whl

mm_eth/cli/cmd/transfer_cmd.py

@@ -1,24 +1,23 @@
+import asyncio
 import sys
 import time
 from pathlib import Path
-from typing import Annotated, Self
+from typing import Annotated, Literal, Self, cast
 
 import mm_crypto_utils
 from loguru import logger
-from mm_crypto_utils import AddressToPrivate, Transfer
-from mm_std import BaseConfig, Err, fatal, utc_now
+from mm_crypto_utils import AddressToPrivate, Transfer, VarInt
+from mm_std import BaseConfig, utc_now
 from pydantic import AfterValidator, BeforeValidator, Field, model_validator
 from rich.console import Console
 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 import converters, erc20, retry, tx
+from mm_eth.cli import calcs, cli_utils
 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
+from mm_eth.converters import from_wei
 
 
 class Config(BaseConfig):
@@ -45,8 +44,8 @@ class Config(BaseConfig):
     def from_addresses(self) -> list[str]:
         return [r.from_address for r in self.transfers]
 
-    @model_validator(mode="after")
-    def final_validator(self) -> Self:
+    @model_validator(mode="after")  # type:ignore[misc]
+    async 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")
 
@@ -69,10 +68,9 @@ class Config(BaseConfig):
                 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
+            self.token_decimals = (await retry.erc20_decimals(5, self.nodes, self.proxies, token=self.token)).unwrap_or_exit(
+                "can't get token decimals"
+            )
 
         return self
 
@@ -85,119 +83,206 @@ class TransferCmdParams(BaseConfigParams):
     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)
+async def run(params: TransferCmdParams) -> None:
+    config = await Config.read_toml_config_or_exit_async(params.config_path)
+    if params.print_config:
+        config.print_and_exit(exclude={"private_keys"})
 
-    if cmd_params.print_transfers:
+    if params.print_transfers:
         _print_transfers(config)
         sys.exit(0)
 
-    if cmd_params.print_balances:
-        _print_balances(config)
+    await cli_utils.check_nodes_for_chain_id(config.nodes, config.chain_id)
+
+    if params.print_balances:
+        await _print_balances(config)
         sys.exit(0)
 
-    _run_transfers(config, cmd_params)
+    await _run_transfers(config, params)
 
 
-def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
+async 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, transfer in enumerate(config.transfers):
-        _transfer(transfer, config, cmd_params)
+        await _transfer(transfer, config, cmd_params)
         if config.delay is not None and i < len(config.transfers) - 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))
+                await asyncio.sleep(float(delay_value))
     logger.info(f"finished at {utc_now()} UTC")
 
 
-def _transfer(t: Transfer, config: Config, cmd_params: TransferCmdParams) -> None:
-    nonce = rpc_helpers.get_nonce(config.nodes, t.from_address, t.log_prefix)
+async def _get_nonce(t: Transfer, config: Config) -> int | None:
+    res = await retry.eth_get_transaction_count(5, config.nodes, config.proxies, address=t.from_address)
+    if res.is_err():
+        logger.error(f"{t.log_prefix}: nonce error: {res.unwrap_error()}")
+        return None
+    logger.debug(f"{t.log_prefix}: nonce={res.unwrap()}")
+    return res.unwrap()
+
+
+async def _calc_max_fee(t: Transfer, config: Config) -> int | None:
+    if "base_fee" in config.max_fee.lower():
+        base_fee_res = await retry.get_base_fee_per_gas(5, config.nodes, config.proxies)
+        if base_fee_res.is_err():
+            logger.error(f"{t.log_prefix}: base_fee error: {base_fee_res.unwrap_error()}")
+            return None
+        logger.debug(f"{t.log_prefix}: base_fee={base_fee_res.unwrap()}")
+        return calcs.calc_eth_expression(config.max_fee, VarInt("base_fee", base_fee_res.unwrap()))
+    return calcs.calc_eth_expression(config.max_fee)
+
+
+def check_max_fee_limit(t: Transfer, config: Config, max_fee: int) -> bool:
+    if config.max_fee_limit:
+        max_fee_limit = calcs.calc_eth_expression(config.max_fee_limit)
+        if max_fee > max_fee_limit:
+            msg = f"{t.log_prefix}: max_fee limit exceeded"
+            msg += f", max_fee={from_wei(max_fee, 'gwei')}gwei, max_fee_limit={from_wei(max_fee_limit, 'gwei')}gwei"
+            logger.error(msg)
+            return False
+    return True
+
+
+async def _calc_gas(t: Transfer, config: Config) -> int | None:
+    var = None
+    if "estimate" in config.gas.lower():
+        if config.token:
+            res = await retry.eth_estimate_gas(
+                5,
+                config.nodes,
+                config.proxies,
+                from_=t.from_address,
+                to=config.token,
+                data=erc20.encode_transfer_input_data(t.to_address, 12345),
+            )
+        else:
+            res = await retry.eth_estimate_gas(
+                5, config.nodes, config.proxies, from_=t.from_address, to=t.to_address, value=12345
+            )
+        if res.is_err():
+            logger.error(f"{t.log_prefix}: gas estimate error: {res.unwrap_error()}")
+            return None
+        logger.debug(f"{t.log_prefix}: gas estimate={res.unwrap()}")
+        var = VarInt("estimate", res.unwrap())
+    return calcs.calc_eth_expression(config.gas, var)
+
+
+async def _calc_eth_value(t: Transfer, max_fee: int, gas: int, config: Config) -> int | None:
+    value_expression = t.value.lower()
+    var = None
+    if "balance" in value_expression:
+        res = await retry.eth_get_balance(5, config.nodes, config.proxies, address=t.from_address)
+        if res.is_err():
+            logger.error(f"{t.log_prefix}: balance error: {res.unwrap_error()}")
+            return None
+        logger.debug(f"{t.log_prefix}: balance={res.unwrap()}")
+        var = VarInt("balance", res.unwrap())
+
+    value = calcs.calc_eth_expression(value_expression, var)
+    if "balance" in value_expression.lower():
+        value = value - gas * max_fee
+    return value
+
+
+async def _calc_token_value(t: Transfer, config: Config) -> int | None:
+    value_expression = t.value.lower()
+    var = None
+    if "balance" in value_expression:
+        res = await retry.erc20_balance(5, config.nodes, config.proxies, token=cast(str, config.token), wallet=t.from_address)
+        if res.is_err():
+            logger.error(f"{t.log_prefix}: balance error: {res.unwrap_error()}")
+            return None
+        logger.debug(f"{t.log_prefix}: balance={res.unwrap()}")
+        var = VarInt("balance", res.unwrap())
+    return calcs.calc_token_expression(value_expression, config.token_decimals, var)
+
+
+async def _calc_value(t: Transfer, max_fee: int, gas: int, config: Config) -> int | None:
+    if config.token:
+        return await _calc_token_value(t, config)
+    return await _calc_eth_value(t, max_fee, gas, config)
+
+
+def _check_value_min_limit(t: Transfer, 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"{t.log_prefix}: value<value_min_limit, value={_value_with_suffix(value, config)}")
+    return True
+
+
+async def _transfer(t: Transfer, config: Config, cmd_params: TransferCmdParams) -> None:
+    nonce = await _get_nonce(t, config)
     if nonce is None:
         return
 
-    max_fee = rpc_helpers.calc_max_fee(config.nodes, config.max_fee, t.log_prefix)
+    max_fee = await _calc_max_fee(t, config)
     if max_fee is None:
         return
 
-    if rpc_helpers.is_max_fee_limit_exceeded(max_fee, config.max_fee_limit, t.log_prefix):
+    if not check_max_fee_limit(t, config, max_fee):
         return
 
-    gas = _calc_gas(t, config)
+    gas = await _calc_gas(t, config)
     if gas is None:
         return
 
-    value = _calc_value(t, max_fee=max_fee, gas=gas, config=config)
+    value = await _calc_value(t, max_fee, gas, config)
     if value is None:
         return
 
     if not _check_value_min_limit(t, value, config):
         return
 
-    priority_fee = calc_eth_expression(config.priority_fee)
+    priority_fee = calcs.calc_eth_expression(config.priority_fee)
 
     # emulate?
     if cmd_params.emulate:
         msg = f"{t.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" max_fee={from_wei(max_fee, 'gwei', config.round_ndigits)}gwei,"
+        msg += f" priority_fee={from_wei(priority_fee, 'gwei', config.round_ndigits)}gwei,"
         msg += f" gas={gas}"
         logger.info(msg)
         return
 
-    tx_hash = _send_tx(transfer=t, nonce=nonce, max_fee=max_fee, priority_fee=priority_fee, gas=gas, value=value, config=config)
+    tx_hash = await _send_tx(
+        transfer=t, 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"{t.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)
+        status = await wait_tx_status(t, tx_hash, config)
 
     logger.info(f"{t.log_prefix}: tx_hash={tx_hash}, value={_value_with_suffix(value, config)},  status={status}")
 
 
-def _calc_value(transfer: Transfer, 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=transfer.value,
-            wallet_address=transfer.from_address,
-            token_address=config.token,
-            decimals=config.token_decimals,
-            log_prefix=transfer.log_prefix,
-        )
-    return rpc_helpers.calc_eth_value_for_address(
-        nodes=config.nodes,
-        value_expression=transfer.value,
-        address=transfer.from_address,
-        gas=gas,
-        max_fee=max_fee,
-        log_prefix=transfer.log_prefix,
-    )
+async def wait_tx_status(t: Transfer, tx_hash: str, config: Config) -> Literal["OK", "FAIL", "TIMEOUT"]:
+    logger.debug(f"{t.log_prefix}: waiting for receipt, tx_hash={tx_hash}")
+    started_at = time.perf_counter()
+    count = 0
+    while True:
+        res = await retry.get_tx_status(5, config.nodes, config.proxies, tx_hash=tx_hash)
+        logger.debug(f"{t.log_prefix}: status={res.value_or_error()}")
+        if res.is_ok():
+            return "OK" if res.unwrap() == 1 else "FAIL"
 
-
-def _check_value_min_limit(transfer: Transfer, 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"{transfer.log_prefix}: value<value_min_limit, value={_value_with_suffix(value, config)}")
-    return True
+        await asyncio.sleep(1)
+        count += 1
+        if time.perf_counter() - started_at > config.wait_tx_timeout:
+            return "TIMEOUT"
 
 
-def _send_tx(
+async def _send_tx(
     *, transfer: Transfer, nonce: int, max_fee: int, priority_fee: int, gas: int, value: int, config: Config
 ) -> str | None:
     debug_tx_params = {
@@ -224,7 +309,7 @@ def _send_tx(
             recipient_address=transfer.to_address,
         )
     else:
-        signed_tx = sign_tx(
+        signed_tx = tx.sign_tx(
             nonce=nonce,
             max_fee_per_gas=max_fee,
             max_priority_fee_per_gas=priority_fee,
@@ -234,31 +319,13 @@ def _send_tx(
             value=value,
             to=transfer.to_address,
         )
-    res = rpc.eth_send_raw_transaction(config.nodes, signed_tx.raw_tx, attempts=5)
-    if isinstance(res, Err):
-        logger.info(f"{transfer.log_prefix}: tx error {res.err}")
+    res = await retry.eth_send_raw_transaction(5, config.nodes, config.proxies, raw_tx=signed_tx.raw_tx)
+    if res.is_err():
+        logger.error(f"{transfer.log_prefix}: send tx error={res.unwrap_error()}")
         return None
-    return res.ok
-
+    logger.debug(f"{transfer.log_prefix}: tx_hash={res.unwrap()}")
 
-def _calc_gas(transfer: Transfer, config: Config) -> int | None:
-    if config.token:
-        return rpc_helpers.calc_gas(
-            nodes=config.nodes,
-            gas_expression=config.gas,
-            from_address=transfer.from_address,
-            to_address=config.token,
-            data=erc20.encode_transfer_input_data(transfer.to_address, 1234),
-            log_prefix=transfer.log_prefix,
-        )
-    return rpc_helpers.calc_gas(
-        nodes=config.nodes,
-        gas_expression=config.gas,
-        from_address=transfer.from_address,
-        to_address=transfer.to_address,
-        value=123,
-        log_prefix=transfer.log_prefix,
-    )
+    return res.unwrap()
 
 
 def _print_transfers(config: Config) -> None:
@@ -269,7 +336,7 @@ def _print_transfers(config: Config) -> None:
     console.print(table)
 
 
-def _print_balances(config: Config) -> None:
+async def _print_balances(config: Config) -> None:
     if config.token:
         headers = ["n", "from_address", "nonce", "eth", "t", "to_address", "nonce", "eth", "t"]
     else:
@@ -277,18 +344,52 @@ def _print_balances(config: Config) -> None:
     table = Table(*headers, title="balances")
     with Live(table, refresh_per_second=0.5):
         for count, transfer in enumerate(config.transfers):
-            from_nonce = _get_nonce_str(transfer.from_address, config)
-            to_nonce = _get_nonce_str(transfer.to_address, config)
+            from_nonce = (
+                await retry.eth_get_transaction_count(5, config.nodes, config.proxies, address=transfer.from_address)
+            ).value_or_error()
+            to_nonce = (
+                await retry.eth_get_transaction_count(5, config.nodes, config.proxies, address=transfer.to_address)
+            ).value_or_error()
+
+            from_eth_balance = (
+                (await retry.eth_get_balance(5, config.nodes, config.proxies, address=transfer.from_address))
+                .map(lambda value: converters.from_wei(value, "ether", config.round_ndigits))
+                .value_or_error()
+            )
+
+            to_eth_balance = (
+                (await retry.eth_get_balance(5, config.nodes, config.proxies, address=transfer.to_address))
+                .map(lambda value: converters.from_wei(value, "ether", config.round_ndigits))
+                .value_or_error()
+            )
 
-            from_eth_balance = _get_eth_balance_str(transfer.from_address, config)
-            to_eth_balance = _get_eth_balance_str(transfer.to_address, config)
-
-            from_token_balance = _get_token_balance_str(transfer.from_address, config) if config.token else ""
-            to_token_balance = _get_token_balance_str(transfer.to_address, config) if config.token else ""
+            if config.token:
+                from_token_balance = (
+                    (await retry.erc20_balance(5, config.nodes, config.proxies, token=config.token, wallet=transfer.from_address))
+                    .map(
+                        lambda value: converters.from_wei(
+                            value, "t", decimals=config.token_decimals, round_ndigits=config.round_ndigits
+                        )
+                    )
+                    .value_or_error()
+                )
+                to_token_balance = (
+                    (await retry.erc20_balance(5, config.nodes, config.proxies, token=config.token, wallet=transfer.to_address))
+                    .map(
+                        lambda value: converters.from_wei(
+                            value, "t", decimals=config.token_decimals, round_ndigits=config.round_ndigits
+                        )
+                    )
+                    .value_or_error()
+                )
+            else:
+                from_token_balance = ""  # nosec
+                to_token_balance = ""  # nosec
 
             if config.token:
-                table.add_row(
-                    str(count),
+                cli_utils.add_table_raw(
+                    table,
+                    count,
                     transfer.from_address,
                     from_nonce,
                     from_eth_balance,
@@ -299,8 +400,9 @@ def _print_balances(config: Config) -> None:
                     to_token_balance,
                 )
             else:
-                table.add_row(
-                    str(count),
+                cli_utils.add_table_raw(
+                    table,
+                    count,
                     transfer.from_address,
                     from_nonce,
                     from_eth_balance,
@@ -310,27 +412,7 @@ def _print_balances(config: Config) -> None:
                 )
 
 
-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)
+        return f"{from_wei(value, 't', config.round_ndigits, decimals=config.token_decimals)}t"
+    return f"{from_wei(value, 'eth', config.round_ndigits)}eth"

mm_eth/cli/cmd/wallet/private_key_cmd.py

@@ -4,7 +4,8 @@ from mm_eth import account
 
 
 def run(private_key: str) -> None:
-    try:
-        print_plain(account.private_to_address(private_key))
-    except Exception as e:
-        fatal(f"wrong private key: {e}")
+    res = account.private_to_address(private_key)
+    if res.is_ok():
+        print_plain(res.unwrap())
+    else:
+        fatal(f"invalid private key: '{private_key}'")

mm_eth/cli/rpc_helpers.py

@@ -1,133 +1,50 @@
-import mm_crypto_utils
-from loguru import logger
-from mm_crypto_utils import VarInt, get_log_prefix
-from mm_std import Err, fatal
+import logging
 
-from mm_eth import erc20, rpc
-from mm_eth.utils import from_wei_str
+from mm_crypto_utils import Nodes, Proxies, VarInt
 
-from .calcs import calc_eth_expression
+from mm_eth import retry
+from mm_eth.cli import calcs
 
+logger = logging.getLogger(__name__)
 
-def get_nonce(nodes: list[str] | str, address: str, log_prefix: str | None = None) -> int | None:
-    res = rpc.eth_get_transaction_count(nodes, address, attempts=5)
+
+async def get_nonce_with_logging(
+    log_prefix: str | None, retries: int, nodes: Nodes, proxies: Proxies, *, address: str
+) -> int | None:
+    res = await retry.eth_get_transaction_count(retries, nodes, proxies, address=address)
     prefix = log_prefix or address
-    logger.debug(f"{prefix}: nonce={res.ok_or_err()}")
-    if isinstance(res, Err):
-        logger.info(f"{prefix}: nonce error, {res.err}")
+    if res.is_err():
+        logger.error(f"{prefix}: nonce error: {res.unwrap_error()}")
         return None
-    return res.ok
-
+    logger.debug(f"{prefix}: nonce={res.unwrap()}")
+    return res.unwrap()
 
-def check_nodes_for_chain_id(nodes: list[str], chain_id: int) -> None:
-    for node in nodes:
-        res = rpc.eth_chain_id(node, timeout=7)
-        if isinstance(res, Err):
-            fatal(f"can't get chain_id for {node}, error={res.err}")
-        if res.ok != chain_id:
-            fatal(f"node {node} has a wrong chain_id: {res.ok}")
 
-
-def get_base_fee(nodes: list[str], log_prefix: str | None = None) -> int | None:
-    res = rpc.get_base_fee_per_gas(nodes)
+async def get_base_fee_with_logging(log_prefix: str | None, retries: int, nodes: Nodes, proxies: Proxies) -> int | None:
     prefix = get_log_prefix(log_prefix)
-    logger.debug(f"{prefix}base_fee={res.ok_or_err()}")
-    if isinstance(res, Err):
-        logger.info(f"{prefix}base_fee error, {res.err}")
+    res = await retry.get_base_fee_per_gas(retries, nodes, proxies)
+    if res.is_err():
+        logger.error(f"{prefix}base_fee error, {res.unwrap_error()}")
         return None
-    return res.ok
-
-
-def calc_max_fee(nodes: list[str], max_fee_expression: str, log_prefix: str | None = None) -> int | None:
-    if "base_fee" in max_fee_expression.lower():
-        base_fee = get_base_fee(nodes, log_prefix)
-        if base_fee is None:
-            return None
-        return calc_eth_expression(max_fee_expression, VarInt("base_fee", base_fee))
-
-    return calc_eth_expression(max_fee_expression)
 
+    logger.debug(f"{prefix}base_fee={res.unwrap()}")
+    return res.unwrap()
 
-def is_max_fee_limit_exceeded(max_fee: int, max_fee_limit_expression: str | None, log_prefix: str | None = None) -> bool:
-    if max_fee_limit_expression is None:
-        return False
-    max_limit_value = calc_eth_expression(max_fee_limit_expression)
-    if max_fee > max_limit_value:
-        prefix = get_log_prefix(log_prefix)
-        logger.info(
-            "{}max_fee_limit is exceeded, max_fee={}, max_fee_limit={}",
-            prefix,
-            from_wei_str(max_fee, "gwei"),
-            from_wei_str(max_limit_value, "gwei"),
-        )
-        return True
-    return False
 
-
-def calc_gas(
-    *,
-    nodes: list[str],
-    gas_expression: str,
-    from_address: str,
-    to_address: str,
-    value: int | None = None,
-    data: str | None = None,
-    log_prefix: str | None = None,
-) -> int | None:
-    var = None
-    if "estimate" in gas_expression.lower():
-        prefix = get_log_prefix(log_prefix)
-        res = rpc.eth_estimate_gas(nodes, from_address, to_address, data=data, value=value, attempts=5)
-        logger.debug(f"{prefix}gas_estimate={res.ok_or_err()}")
-        if isinstance(res, Err):
-            logger.info(f"{prefix}estimate_gas error, {res.err}")
-            return None
-        var = VarInt("estimate", res.ok)
-    return calc_eth_expression(gas_expression, var)
-
-
-def calc_eth_value_for_address(
-    *,
-    nodes: list[str],
-    value_expression: str,
-    address: str,
-    gas: int,
-    max_fee: int,
-    log_prefix: str | None = None,
+async def calc_max_fee_with_logging(
+    log_prefix: str | None, retries: int, nodes: Nodes, proxies: Proxies, *, max_fee_expression: str
 ) -> int | None:
-    var = None
-    if "balance" in value_expression.lower():
-        prefix = get_log_prefix(log_prefix)
-        res = rpc.eth_get_balance(nodes, address, attempts=5)
-        logger.debug(f"{prefix}balance={res.ok_or_err()}")
-        if isinstance(res, Err):
-            logger.info(f"{prefix}balance error, {res.err}")
+    if "base_fee" in max_fee_expression.lower():
+        base_fee = await get_base_fee_with_logging(log_prefix, retries, nodes, proxies)
+        if base_fee is None:
             return None
-        var = VarInt("balance", res.ok)
+        return calcs.calc_eth_expression(max_fee_expression, VarInt("base_fee", base_fee))
 
-    value = calc_eth_expression(value_expression, var)
-    if "balance" in value_expression.lower():
-        value = value - gas * max_fee
-    return value
+    return calcs.calc_eth_expression(max_fee_expression)
 
 
-def calc_erc20_value_for_address(
-    *,
-    nodes: list[str],
-    value_expression: str,
-    wallet_address: str,
-    token_address: str,
-    decimals: int,
-    log_prefix: str | None = None,
-) -> int | None:
-    value_expression = value_expression.lower()
-    var = None
-    if "balance" in value_expression:
-        prefix = get_log_prefix(log_prefix)
-        res = erc20.get_balance(nodes, token_address, wallet_address, attempts=5)
-        logger.debug(f"{prefix}balance={res.ok_or_err()}")
-        if isinstance(res, Err):
-            logger.info(f"{prefix}balance error, {res.err}")
-            return None
-        var = VarInt("balance", res.ok)
-    return mm_crypto_utils.calc_int_expression(value_expression, var, suffix_decimals={"t": decimals})
+def get_log_prefix(log_prefix: str | None) -> str:
+    prefix = log_prefix or ""
+    if prefix:
+        prefix += ": "
+    return prefix