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

mm_eth/cli/cmd/transfer_eth_cmd.py

@@ -1,180 +1,110 @@
 import sys
 import time
 from pathlib import Path
-from typing import Self
+from typing import Annotated, Self
 
+import mm_crypto_utils
 from loguru import logger
-from mm_std import BaseConfig, Err, Ok, str_to_list, utc_now
-from pydantic import Field, StrictStr, field_validator, model_validator
+from mm_crypto_utils import AddressToPrivate, TxRoute
+from mm_std import BaseConfig, Err, Ok, utc_now
+from pydantic import AfterValidator, BeforeValidator, model_validator
 
 from mm_eth import rpc
-from mm_eth.account import create_private_keys_dict, private_to_address
-from mm_eth.cli import calcs, cli_utils, print_helpers, rpc_helpers, validators
+from mm_eth.cli import cli_utils, print_helpers, 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 as Validators
 from mm_eth.tx import sign_tx
 from mm_eth.utils import from_wei_str
 
 
+# noinspection DuplicatedCode
 class Config(BaseConfig):
-    class Tx(BaseConfig):
-        from_address: str
-        to_address: str
-
-    nodes: list[StrictStr]
+    nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
     chain_id: int
-    private_keys: dict[str, str] = Field(default_factory=dict)
-    private_keys_file: str | None = None
-    max_fee_per_gas: str
-    max_fee_per_gas_limit: str | None = None
-    max_priority_fee_per_gas: str
-    value: str
-    value_min_limit: str | None = None
-    gas: str
-    addresses_map: str | None = None
-    addresses_from_file: str | None = None
-    addresses_to_file: str | None = None
-    delay: str | None = None  # in seconds
+    routes: Annotated[list[TxRoute], BeforeValidator(Validators.eth_routes())]
+    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.eth_private_keys())]
+    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_expression("balance"))]
+    value_min_limit: Annotated[str | None, AfterValidator(Validators.valid_eth_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
-    log_debug: str | None = None
-    log_info: str | None = None
-    txs: list[Tx] = Field(default_factory=list)
+    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 [tx.from_address for tx in self.txs]
-
-    @field_validator("log_debug", "log_info", mode="before")
-    def log_validator(cls, v: str | None) -> str | None:
-        return validators.log_validator(v)
-
-    @field_validator("nodes", mode="before")
-    def nodes_validator(cls, v: str | list[str] | None) -> list[str]:
-        return validators.nodes_validator(v)
-
-    @field_validator("private_keys", mode="before")
-    def private_keys_validator(cls, v: str | list[str] | None) -> dict[str, str]:
-        if v is None:
-            return {}
-        if isinstance(v, str):
-            return create_private_keys_dict(str_to_list(v, unique=True, remove_comments=True))
-        return create_private_keys_dict(v)
+        return [r.from_address for r in self.routes]
 
-    # noinspection DuplicatedCode
     @model_validator(mode="after")
     def final_validator(self) -> Self:
-        # load private keys from file
-        if self.private_keys_file:
-            file = Path(self.private_keys_file).expanduser()
-            if not file.is_file():
-                raise ValueError("can't read private_keys_file")
-            for line in file.read_text().strip().split("\n"):
-                line = line.strip()  # noqa: PLW2901
-                address = private_to_address(line)
-                if address is None:
-                    raise ValueError("there is not a private key in private_keys_file")
-                self.private_keys[address.lower()] = line
-
-        # max_fee_per_gas
-        if not validators.is_valid_calc_var_wei_value(self.max_fee_per_gas, "base"):
-            raise ValueError(f"wrong max_fee_per_gas: {self.max_fee_per_gas}")
-
-        # max_fee_per_gas_limit
-        if not validators.is_valid_calc_var_wei_value(self.max_fee_per_gas_limit, "base"):
-            raise ValueError(f"wrong max_fee_per_gas_limit: {self.max_fee_per_gas_limit}")
-
-        # max_priority_fee_per_gas
-        if not validators.is_valid_calc_var_wei_value(self.max_priority_fee_per_gas):
-            raise ValueError(f"wrong max_priority_fee_per_gas: {self.max_priority_fee_per_gas}")
-
-        # value
-        if not validators.is_valid_calc_var_wei_value(self.value, "balance"):
-            raise ValueError(f"wrong value: {self.value}")
-
-        # value_min_limit
-        if not validators.is_valid_calc_var_wei_value(self.value_min_limit):
-            raise ValueError(f"wrong value_min_limit: {self.value_min_limit}")
-
-        # gas
-        if not validators.is_valid_calc_var_wei_value(self.gas, "estimate"):
-            raise ValueError(f"wrong gas: {self.gas}")
-
-        # delay
-        if not validators.is_valid_calc_decimal_value(self.delay):
-            raise ValueError(f"wrong delay: {self.delay}")
-
-        # txs
-        if self.addresses_map:
-            for tx in cli_utils.load_tx_addresses_from_str(self.addresses_map):
-                self.txs.append(Config.Tx(from_address=tx[0], to_address=tx[1]))
-        if self.addresses_from_file and self.addresses_to_file:
-            self.txs.extend(
-                Config.Tx(from_address=tx[0], to_address=tx[1])
-                for tx in cli_utils.load_tx_addresses_from_files(self.addresses_from_file, self.addresses_to_file)
-            )
-        if not self.txs:
-            raise ValueError("txs is empty")
+        if not self.private_keys.contains_all_addresses(self.from_addresses):
+            raise ValueError("private keys are not set for all addresses")
 
         return self
 
 
-def run(
-    config_path: str,
-    *,
-    print_balances: bool,
-    print_config: bool,
-    debug: bool,
-    no_receipt: bool,
-    emulate: bool,
-) -> None:
-    config = Config.read_config_or_exit(config_path)
-    cli_utils.print_config_and_exit(print_config, config, {"private_key", "addresses_map"})
+class TransferEthCmdParams(BaseConfigParams):
+    print_balances: bool
+    debug: bool
+    no_receipt: bool
+    emulate: bool
 
-    cli_utils.init_logger(debug, config.log_debug, config.log_info)
+
+def run(cli_params: TransferEthCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(cli_params.config_path)
+    if cli_params.print_config_and_exit:
+        config.print_and_exit({"private_keys"})
+
+    mm_crypto_utils.init_logger(cli_params.debug, config.log_debug, config.log_info)
     rpc_helpers.check_nodes_for_chain_id(config.nodes, config.chain_id)
 
-    if print_balances:
+    if cli_params.print_balances:
         print_helpers.print_balances(config.nodes, config.from_addresses, round_ndigits=config.round_ndigits)
         sys.exit(0)
 
-    return _run_transfers(config, no_receipt=no_receipt, emulate=emulate)
+    return _run_transfers(config, cli_params)
 
 
 # noinspection DuplicatedCode
-def _run_transfers(config: Config, *, no_receipt: bool, emulate: bool) -> None:
+def _run_transfers(config: Config, cli_params: TransferEthCmdParams) -> None:
     logger.info(f"started at {utc_now()} UTC")
-    logger.debug(f"config={config.model_dump(exclude={'private_keys', 'addresses_map'}) | {'version': cli_utils.get_version()}}")
-    cli_utils.check_private_keys(config.from_addresses, config.private_keys)
-    for i, tx in enumerate(config.txs):
-        _transfer(from_address=tx.from_address, to_address=tx.to_address, config=config, no_receipt=no_receipt, emulate=emulate)
-        if not emulate and config.delay is not None and i < len(config.txs) - 1:
-            delay_value = calcs.calc_decimal_value(config.delay)
+    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, cli_params)
+        if not cli_params.emulate and config.delay is not None and i < len(config.routes) - 1:
+            delay_value = mm_crypto_utils.calc_decimal_value(config.delay)
             logger.debug(f"delay {delay_value} seconds")
             time.sleep(float(delay_value))
     logger.info(f"finished at {utc_now()} UTC")
 
 
 # noinspection DuplicatedCode
-def _transfer(*, from_address: str, to_address: str, config: Config, no_receipt: bool, emulate: bool) -> None:
-    log_prefix = f"{from_address}->{to_address}"
+def _transfer(route: TxRoute, config: Config, cli_params: TransferEthCmdParams) -> None:
+    log_prefix = f"{route.from_address}->{route.to_address}"
     # get nonce
-    nonce = rpc_helpers.get_nonce(config.nodes, from_address, log_prefix)
+    nonce = rpc_helpers.get_nonce(config.nodes, route.from_address, log_prefix)
     if nonce is None:
         return
 
-    # get max_fee_per_gas
-    max_fee_per_gas = rpc_helpers.calc_max_fee_per_gas(config.nodes, config.max_fee_per_gas, log_prefix)
-    if max_fee_per_gas is None:
+    # get max_fee
+    max_fee = rpc_helpers.calc_max_fee(config.nodes, config.max_fee, log_prefix)
+    if max_fee is None:
         return
 
-    # check max_fee_per_gas_limit
-    if rpc_helpers.is_max_fee_per_gas_limit_exceeded(max_fee_per_gas, config.max_fee_per_gas_limit, log_prefix):
+    # check max_fee_limit
+    if rpc_helpers.is_max_fee_limit_exceeded(max_fee, config.max_fee_limit, log_prefix):
         return
 
     # get gas
     gas = rpc_helpers.calc_gas(
         nodes=config.nodes,
-        gas=config.gas,
-        from_address=from_address,
-        to_address=to_address,
+        gas_expression=config.gas,
+        from_address=route.from_address,
+        to_address=route.to_address,
         value=123,
         log_prefix=log_prefix,
     )
@@ -182,51 +112,54 @@ def _transfer(*, from_address: str, to_address: str, config: Config, no_receipt:
         return
 
     # get value
-    value = rpc_helpers.calc_eth_value(
+    value = rpc_helpers.calc_eth_value_for_address(
         nodes=config.nodes,
-        value_str=config.value,
-        address=from_address,
+        value_expression=config.value,
+        address=route.from_address,
         gas=gas,
-        max_fee_per_gas=max_fee_per_gas,
+        max_fee=max_fee,
         log_prefix=log_prefix,
     )
     if value is None:
         return
 
     # value_min_limit
-    if calcs.is_value_less_min_limit(config.value_min_limit, value, "eth", log_prefix=log_prefix):
-        return
+    if config.value_min_limit is not None:
+        value_min_limit = calc_eth_expression(config.value_min_limit)
+        if value < value_min_limit:
+            logger.info(f"{log_prefix}value<value_min_limit, value={from_wei_str(value, 'eth', config.round_ndigits)}")
+            return
 
-    max_priority_fee_per_gas = calcs.calc_var_wei_value(config.max_priority_fee_per_gas)
-    tx_params = {
-        "nonce": nonce,
-        "max_fee_per_gas": max_fee_per_gas,
-        "max_priority_fee_per_gas": max_priority_fee_per_gas,
-        "gas": gas,
-        "value": value,
-        "to": to_address,
-        "chain_id": config.chain_id,
-    }
+    priority_fee = calc_eth_expression(config.priority_fee)
 
     # emulate?
-    if emulate:
+    if cli_params.emulate:
         msg = f"{log_prefix}: emulate, value={from_wei_str(value, 'eth', config.round_ndigits)},"
-        msg += f" max_fee_per_gas={from_wei_str(max_fee_per_gas, 'gwei', config.round_ndigits)},"
-        msg += f" max_priority_fee_per_gas={from_wei_str(max_priority_fee_per_gas, 'gwei', config.round_ndigits)},"
+        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
 
-    logger.debug(f"{log_prefix}: tx_params={tx_params}")
+    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"{log_prefix}: tx_params={debug_tx_params}")
     signed_tx = sign_tx(
         nonce=nonce,
-        max_fee_per_gas=max_fee_per_gas,
-        max_priority_fee_per_gas=max_priority_fee_per_gas,
+        max_fee_per_gas=max_fee,
+        max_priority_fee_per_gas=priority_fee,
         gas=gas,
-        private_key=config.private_keys[from_address],
+        private_key=config.private_keys[route.from_address],
         chain_id=config.chain_id,
         value=value,
-        to=to_address,
+        to=route.to_address,
     )
     res = rpc.eth_send_raw_transaction(config.nodes, signed_tx.raw_tx, attempts=5)
     if isinstance(res, Err):
@@ -234,12 +167,12 @@ def _transfer(*, from_address: str, to_address: str, config: Config, no_receipt:
         return
     tx_hash = res.ok
 
-    if no_receipt:
+    if cli_params.no_receipt:
         msg = f"{log_prefix}: tx_hash={tx_hash}, value={from_wei_str(value, 'ether', round_ndigits=config.round_ndigits)}"
         logger.info(msg)
     else:
         logger.debug(f"{log_prefix}: tx_hash={tx_hash}, wait receipt")
-        while True:
+        while True:  # TODO: infinite loop if receipt_res is err
             receipt_res = rpc.get_tx_status(config.nodes, tx_hash)
             if isinstance(receipt_res, Ok):
                 status = "OK" if receipt_res.ok == 1 else "FAIL"

mm_eth/cli/cmd/tx_cmd.py

@@ -0,0 +1,16 @@
+from eth_typing import HexStr
+from rich.pretty import pprint
+from web3 import Web3
+
+from mm_eth.cli.cli_utils import public_rpc_url
+
+
+def run(rpc_url: str, tx_hash: str, get_receipt: bool) -> None:
+    rpc_url = public_rpc_url(rpc_url)
+    w3 = Web3(Web3.HTTPProvider(rpc_url))
+    transaction = w3.eth.get_transaction(HexStr(tx_hash))
+    pprint(dict(transaction), expand_all=True)
+
+    if get_receipt:
+        receipt = w3.eth.get_transaction_receipt(HexStr(tx_hash))
+        pprint(dict(receipt), expand_all=True)

mm_eth/cli/cmd/vault_cmd.py

@@ -1,11 +1,14 @@
+from pathlib import Path
+
+import mm_crypto_utils
 from mm_std import fatal, print_plain
 
 from mm_eth import vault
-from mm_eth.cli import cli_utils
+from mm_eth.account import is_private_key
 
 
-def run(keys_url: str, vault_token: str, keys_file: str) -> None:
-    private_keys = cli_utils.load_private_keys_from_file(keys_file)
+def run(keys_url: str, vault_token: str, keys_file: Path) -> None:
+    private_keys = mm_crypto_utils.read_items_from_file(keys_file, is_private_key)
     if not private_keys:
         fatal("private keys not found")
 

mm_eth/cli/config_examples/{balances.yml → balances.toml}

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

mm_eth/cli/config_examples/call_contract.toml

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

mm_eth/cli/config_examples/transfer_erc20.toml

@@ -0,0 +1,27 @@
+routes = """
+0x10fd602Bff689e64D4720D1DCCCD3494f1f16623 0x58487485c3858109f5A37e42546FE87473f79a4b
+0x97C77B548aE0d4925F5C201220fC6d8996424309 0x7EdF3b8579c21A8820b4C0B8352541c1CE04045f # can comment here
+"""
+private_keys = """
+0x7bb5b9c0ba991275f84b796b4d25fd3a8d7320911f50fade85410e7a2b000632
+0xb7e0b671e176b04ceb0897a698d34771bfe9acf29273dc52a141be6e97145a00
+file: /path/to/other_private_keys.txt
+"""
+token = "0x60631C856303731BE4deb81C0303F80B652aA5b4" # USDC
+decimals = 6
+max_fee = "1.2base_fee + 1gwei + random(1,200)" # supported var_name=base_fee
+max_fee_limit = "10.1gwei - random(1, 10)" # optional
+priority_fee = "1gwei + random(1, 12)"
+gas = "estimate + random(100, 200) - 19" # supported var_name=estimate
+value = "0.5balance - random(1.5t, 3t) + 11t" # supported var_name=balance
+value_min_limit = "0.5t + random(1, 2) - 7"
+
+delay = "random(1.123, 10) + 1" # secs, optional
+log_debug = "/path/to/file_debug.log" # optional
+log_info = "/path/to/file_info.log" # optional
+round_ndigits = 6 # optional, default=5
+chain_id = 421613
+nodes = """
+https://arbitrum-goerli.publicnode.com
+https://rpc.goerli.arbitrum.gateway.fm
+"""

mm_eth/cli/config_examples/transfer_eth.toml

@@ -0,0 +1,26 @@
+routes = """
+  0x10fd602Bff689e64D4720D1DCCCD3494f1f16623 0x58487485c3858109f5A37e42546FE87473f79a4b
+  0x97C77B548aE0d4925F5C201220fC6d8996424309 0x7EdF3b8579c21A8820b4C0B8352541c1CE04045f # can comment here
+  file: /path/from_addresses.txt /path/to_addresses.txt
+"""
+private_keys = """
+# 0x7bb5b9c0ba991275f84b796b4d25fd3a8d7320911f50fade85410e7a2b000632
+0xb7e0b671e176b04ceb0897a698d34771bfe9acf29273dc52a141be6e97145a00
+file: /path/to/private_keys.txt
+"""
+max_fee = "1.2base + 1gwei + random(1, 200)" # supported var_name=base
+max_fee_limit = "10.1gwei - random(1, 10)" # optional
+priority_fee = "1gwei + random(1, 12)"
+gas = "estimate + random(100, 200) - 19" # supported var_name=estimate
+value = "balance - random(0.002eth, 0.0025eth) + 11gwei" # supported var_name=balance. If 'balance' is used, value=calc(value) - gas*max_fee_per_gas
+value_min_limit = "0.001eth + random(1, 2) - 7gwei"
+
+delay = "random(1.123,10) + 1" # secs
+log_debug = "/path/to/file_debug.log" # optional
+log_info = "/path/to/file_info.log" # optional
+round_ndigits = 6
+chain_id = 421613
+nodes = """
+  https://arbitrum-goerli.publicnode.com
+  https://rpc.goerli.arbitrum.gateway.fm
+"""

mm_eth/cli/rpc_helpers.py

@@ -1,10 +1,12 @@
+import mm_crypto_utils
 from loguru import logger
+from mm_crypto_utils import VarInt, get_log_prefix
 from mm_std import Err, fatal
 
 from mm_eth import erc20, rpc
 from mm_eth.utils import from_wei_str
 
-from . import calcs
+from .calcs import calc_eth_expression
 
 
 def get_nonce(nodes: list[str] | str, address: str, log_prefix: str | None = None) -> int | None:
@@ -28,7 +30,7 @@ def check_nodes_for_chain_id(nodes: list[str], chain_id: int) -> None:
 
 def get_base_fee(nodes: list[str], log_prefix: str | None = None) -> int | None:
     res = rpc.get_base_fee_per_gas(nodes)
-    prefix = _get_prefix(log_prefix)
+    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}")
@@ -36,30 +38,27 @@ def get_base_fee(nodes: list[str], log_prefix: str | None = None) -> int | None:
     return res.ok
 
 
-def calc_max_fee_per_gas(nodes: list[str], max_fee_per_gas: str, log_prefix: str | None = None) -> int | None:
-    if "base" in max_fee_per_gas.lower():
+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 calcs.calc_var_wei_value(max_fee_per_gas, var_name="base", var_value=base_fee)
-    return calcs.calc_var_wei_value(max_fee_per_gas)
+        return calc_eth_expression(max_fee_expression, VarInt("base_fee", base_fee))
 
+    return calc_eth_expression(max_fee_expression)
 
-def is_max_fee_per_gas_limit_exceeded(
-    max_fee_per_gas: int,
-    max_fee_per_gas_limit: str | None,
-    log_prefix: str | None = None,
-) -> bool:
-    if max_fee_per_gas_limit is None:
+
+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_fee_per_gas_limit_value = calcs.calc_var_wei_value(max_fee_per_gas_limit)
-    if max_fee_per_gas > max_fee_per_gas_limit_value:
-        prefix = _get_prefix(log_prefix)
+    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_per_gas_limit is exeeded, max_fee_per_gas={}, max_fee_per_gas_limit={}",
+            "{}max_fee_limit is exceeded, max_fee={}, max_fee_limit={}",
             prefix,
-            from_wei_str(max_fee_per_gas, "gwei"),
-            from_wei_str(max_fee_per_gas_limit_value, "gwei"),
+            from_wei_str(max_fee, "gwei"),
+            from_wei_str(max_limit_value, "gwei"),
         )
         return True
     return False
@@ -68,73 +67,67 @@ def is_max_fee_per_gas_limit_exceeded(
 def calc_gas(
     *,
     nodes: list[str],
-    gas: 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:
-    estimate_value = None
-    if "estimate" in gas.lower():
-        prefix = _get_prefix(log_prefix)
+    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
-        estimate_value = res.ok
-    return calcs.calc_var_wei_value(gas, var_name="estimate", var_value=estimate_value)
+        var = VarInt("estimate", res.ok)
+    return calc_eth_expression(gas_expression, var)
 
 
-def calc_eth_value(
+def calc_eth_value_for_address(
     *,
     nodes: list[str],
-    value_str: str,
+    value_expression: str,
     address: str,
-    gas: int | None = None,
-    max_fee_per_gas: int | None = None,
+    gas: int,
+    max_fee: int,
     log_prefix: str | None = None,
 ) -> int | None:
-    balance_value = None
-    if "balance" in value_str.lower():
-        prefix = _get_prefix(log_prefix)
+    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}")
             return None
-        balance_value = res.ok
-    value = calcs.calc_var_wei_value(value_str, var_name="balance", var_value=balance_value)
-    if "balance" in value_str.lower() and gas is not None and max_fee_per_gas is not None:
-        value = value - gas * max_fee_per_gas
+        var = VarInt("balance", res.ok)
+
+    value = calc_eth_expression(value_expression, var)
+    if "balance" in value_expression.lower():
+        value = value - gas * max_fee
     return value
 
 
-def calc_erc20_value(
+def calc_erc20_value_for_address(
     *,
     nodes: list[str],
-    value_str: str,
+    value_expression: str,
     wallet_address: str,
     token_address: str,
     decimals: int,
     log_prefix: str | None = None,
 ) -> int | None:
-    value_str = value_str.lower()
-    balance_value = None
-    if "balance" in value_str:
-        prefix = _get_prefix(log_prefix)
+    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
-        balance_value = res.ok
-    return calcs.calc_var_wei_value(value_str, var_name="balance", var_value=balance_value, decimals=decimals)
-
-
-def _get_prefix(log_prefix: str | None) -> str:
-    prefix = log_prefix or ""
-    if prefix:
-        prefix += ": "
-    return prefix
+        var = VarInt("balance", res.ok)
+    return mm_crypto_utils.calc_int_expression(value_expression, var, suffix_decimals={"t": decimals})