mm-eth 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

mm_eth/account.py

@@ -13,9 +13,12 @@ Account.enable_unaudited_hdwallet_features()
 
 key_api = KeyAPI()
 
+DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/{i}"
+
 
 @dataclass
-class NewAccount:
+class DerivedAccount:
+    index: int
     path: str
     address: str
     private_key: str
@@ -30,18 +33,15 @@ def generate_mnemonic(num_words: int = 24) -> str:
     return mnemonic.generate(num_words=num_words)
 
 
-def generate_accounts(  # nosec
-    mnemonic: str,
-    passphrase: str = "",
-    path_prefix: str = "m/44'/60'/0'/0",
-    limit: int = 12,
-) -> list[NewAccount]:
-    result: list[NewAccount] = []
+def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit: int) -> list[DerivedAccount]:
+    if "{i}" not in derivation_path:
+        raise ValueError("derivation_path must contain {i}, for example: " + DEFAULT_DERIVATION_PATH)
+    result: list[DerivedAccount] = []
     for i in range(limit):
-        path = f"{path_prefix}/{i}"
-        acc = Account.from_mnemonic(mnemonic=mnemonic, account_path=path, passphrase=passphrase)
+        path = derivation_path.replace("{i}", str(i))
+        acc = Account.from_mnemonic(mnemonic, passphrase, path)
         private_key = acc.key.to_0x_hex().lower()
-        result.append(NewAccount(path, acc.address, private_key))
+        result.append(DerivedAccount(i, path, acc.address, private_key))
     return result
 
 

mm_eth/cli/calcs.py

@@ -10,58 +10,8 @@ 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_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_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:
@@ -75,19 +25,3 @@ def calc_function_args(value: str) -> str:
             raise ValueError("wrong random(from,to) template")
         rand_value = str(random.randint(random_range[0], random_range[1]))
         value = value[0:start_index] + rand_value + value[stop_index + 1 :]
-
-
-# def is_value_less_min_limit(
-#     value_min_limit: str | None,
-#     value: int,
-#     value_unit: str,
-#     decimals: int | None = None,
-#     log_prefix: str | None = None,
-# ) -> bool:
-#     if value_min_limit is None:
-#         return False
-#     if value < calc_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

@@ -5,23 +5,22 @@ from typing import Annotated
 import typer
 from mm_std import PrintFormat, print_plain
 
+from mm_eth.account import DEFAULT_DERIVATION_PATH
+
 from . import cli_utils
 from .cmd import (
     balance_cmd,
     balances_cmd,
     call_contract_cmd,
-    config_example_cmd,
     deploy_cmd,
     encode_input_data_cmd,
-    mnemonic_cmd,
+    example_cmd,
     node_cmd,
-    private_key_cmd,
     rpc_cmd,
     send_contract_cmd,
     solc_cmd,
     token_cmd,
-    transfer_erc20_cmd,
-    transfer_eth_cmd,
+    transfer_cmd,
     tx_cmd,
     vault_cmd,
 )
@@ -29,8 +28,8 @@ 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
+from .cmd.wallet import mnemonic_cmd, private_key_cmd
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
@@ -40,8 +39,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"
 
@@ -77,9 +75,10 @@ def node_command(
 @wallet_app.command(name="mnemonic", help="Generate eth accounts based on a mnemonic")
 def mnemonic_command(  # nosec
     mnemonic: Annotated[str, typer.Option("--mnemonic", "-m")] = "",
-    passphrase: Annotated[str, typer.Option("--passphrase", "-pass")] = "",
+    passphrase: Annotated[str, typer.Option("--passphrase", "-p")] = "",
     print_path: bool = typer.Option(False, "--print_path"),
-    path_prefix: Annotated[str, typer.Option("--path")] = "m/44'/60'/0'/0",
+    derivation_path: Annotated[str, typer.Option("--path")] = DEFAULT_DERIVATION_PATH,
+    words: int = typer.Option(12, "--words", "-w", help="Number of mnemonic words"),
     limit: int = typer.Option(10, "--limit", "-l"),
     save_file: str = typer.Option("", "--save", "-s", help="Save private keys to a file"),
 ) -> None:
@@ -88,7 +87,8 @@ def mnemonic_command(  # nosec
         passphrase=passphrase,
         print_path=print_path,
         limit=limit,
-        path_prefix=path_prefix,
+        words=words,
+        derivation_path=derivation_path,
         save_file=save_file,
     )
 
@@ -141,43 +141,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 +177,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 +192,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 +200,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 +208,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/cli/cli_utils.py

@@ -1,8 +1,14 @@
 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")
@@ -29,4 +35,26 @@ def public_rpc_url(url: str | None) -> str:
 
 class BaseConfigParams(BaseModel):
     config_path: Path
-    print_config_and_exit: bool
+    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/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/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/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/cli/cmd/{config_example_cmd.py → 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/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/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/cli/cmd/{mnemonic_cmd.py → wallet/mnemonic_cmd.py}

@@ -3,18 +3,18 @@ from typing import Any
 
 from mm_std import print_json
 
-from mm_eth.account import generate_accounts, generate_mnemonic
+from mm_eth.account import derive_accounts, generate_mnemonic
 
 
-def run(mnemonic: str, passphrase: str, limit: int, print_path: bool, path_prefix: str, save_file: str) -> None:  # nosec
+def run(mnemonic: str, passphrase: str, words: int, derivation_path: str, limit: int, print_path: bool, save_file: str) -> None:  # nosec
     result: dict[str, Any] = {}
     if not mnemonic:
-        mnemonic = generate_mnemonic()
+        mnemonic = generate_mnemonic(num_words=words)
     result["mnemonic"] = mnemonic
     if passphrase:
         result["passphrase"] = passphrase
     result["accounts"] = []
-    for acc in generate_accounts(mnemonic=mnemonic, passphrase=passphrase, limit=limit, path_prefix=path_prefix):
+    for acc in derive_accounts(mnemonic=mnemonic, passphrase=passphrase, limit=limit, derivation_path=derivation_path):
         new_account = {"address": acc.address, "private": acc.private_key}
         if print_path:
             new_account["path"] = acc.path

mm_eth/cli/{config_examples → 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/cli/{config_examples → 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"

mm_eth/cli/{config_examples/transfer_erc20.toml → examples/transfer.toml}

@@ -2,25 +2,37 @@ routes = """
 0x10fd602Bff689e64D4720D1DCCCD3494f1f16623 0x58487485c3858109f5A37e42546FE87473f79a4b
 0x97C77B548aE0d4925F5C201220fC6d8996424309 0x7EdF3b8579c21A8820b4C0B8352541c1CE04045f # can comment here
 """
+
 private_keys = """
 0x7bb5b9c0ba991275f84b796b4d25fd3a8d7320911f50fade85410e7a2b000632
 0xb7e0b671e176b04ceb0897a698d34771bfe9acf29273dc52a141be6e97145a00
 file: /path/to/other_private_keys.txt
 """
-token = "0x60631C856303731BE4deb81C0303F80B652aA5b4" # USDC
-decimals = 6
+
+token = "0x60631C856303731BE4deb81C0303F80B652aA5b4" # If not specified, it ETH transfers
+
 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 = "0.5balance - random(1.5t, 3t) + 11t" # supported var_name=balance. For ERC20 token use 't' suffix.
+
 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/validators.py

@@ -17,6 +17,10 @@ class Validators(ConfigValidators):
     def valid_token_expression(var_name: str | None = None) -> Callable[[str], str]:
         return ConfigValidators.valid_calc_int_expression(var_name, {"t": 6})
 
+    @staticmethod
+    def valid_eth_or_token_expression(var_name: str | None = None) -> Callable[[str], str]:
+        return ConfigValidators.valid_calc_int_expression(var_name, SUFFIX_DECIMALS | {"t": 6})
+
     @staticmethod
     def eth_routes() -> Callable[[str], list[TxRoute]]:
         return ConfigValidators.routes(is_address, to_lower=True)

{mm_eth-0.3.1.dist-info → mm_eth-0.4.1.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: mm-eth
-Version: 0.3.1
+Version: 0.4.1
 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.dist-info → mm_eth-0.4.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 mm_eth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_eth/abi.py,sha256=Qf-QOsR9QexyQM9XWKNeTMkRarIL3XQJbaDbJ8ifMrw,4856
-mm_eth/account.py,sha256=VjyWOYX5K9ZgdJsHp_I3m-lJ5g9FDo3OJ3knqUPs_TM,1924
+mm_eth/account.py,sha256=k0MNMatBe0zo1iKZiB_Tq6zyEIo22IncD6ewNUJp3dY,2075
 mm_eth/anvil.py,sha256=98RCfI7dEpxFBTV6UErYvubWVP3n0ctUFn1--4kZ84U,1603
 mm_eth/constants.py,sha256=Cy_G-IleBH4gAZ4ok8AGHHlqmdW0ZM7ZldyVpzAfWLs,54
 mm_eth/deploy.py,sha256=SB3ruY808_5UnG8kHR34uVP66P3zOWZu0ImKD7UUv2s,691
@@ -15,35 +15,34 @@ mm_eth/tx.py,sha256=efSoMCoWkenbGdHo1_LX66_Edz1HvED5-J_i3wrHwMw,4051
 mm_eth/utils.py,sha256=sSxt9GZEntZlT0RU8ht9Qon875HPhpd-1JjgqUBEfVo,7405
 mm_eth/vault.py,sha256=h8NyiOQh5YFskh1lZA3KyvnJUnxl9769ME2ChplG0CM,1477
 mm_eth/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_eth/cli/calcs.py,sha256=iHPofMxttXGiJ6h_TqGduzrvfxqQdgYbTHxMWI9u8MA,3845
-mm_eth/cli/cli.py,sha256=1c16hY4SIL2NqCnY5SUBPCSIk3AoBn-kPLs9oZsgB1g,10112
-mm_eth/cli/cli_utils.py,sha256=j09pcGYJ6MfPV-DOjICTB4G8hE2vqb5od19_T2HbGbk,858
+mm_eth/cli/calcs.py,sha256=cLFTYNAN-I53tUiSg-zFfVr2afjIZPftDDjHj16FBz0,1068
+mm_eth/cli/cli.py,sha256=0UYDtNrCXvJqs836tPxsQHs7yTKjvAGL3qgWiXVhnDU,9208
+mm_eth/cli/cli_utils.py,sha256=yBIS3dGid75zyxw8crPOQHA4p3Krk5BoA2g01turKmQ,1712
 mm_eth/cli/print_helpers.py,sha256=yOiOFjTKloumwf07AqNIHQswUo8t0yuT9bpeGBGl60Q,1470
 mm_eth/cli/rpc_helpers.py,sha256=FMV-QVNM3v9X8H_-DP0hjNRqmm7KOnfzkw9bP17Qbz0,4499
-mm_eth/cli/validators.py,sha256=77OFPsl6TGdcy-TKElDa5vumBhaVlgSUiAtkJ2C4RaU,1475
+mm_eth/cli/validators.py,sha256=whnuA4CFkKbcNcbl4e2EwktTSTDGFBTA798E9F_3EM8,1682
 mm_eth/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_eth/cli/cmd/balance_cmd.py,sha256=gkwUa8VGe1wXH0GDsit3-1NmRiijojaNLygi5zNcYSY,2110
-mm_eth/cli/cmd/balances_cmd.py,sha256=X3dzzVlphu9L4YPvm--Iev48zqOHlqtckxV8g1tNbwM,4206
-mm_eth/cli/cmd/call_contract_cmd.py,sha256=nsOIu8JIZNSZwXi-z9TmjRrzhkupyf9zlf8N65l3HZc,1273
-mm_eth/cli/cmd/config_example_cmd.py,sha256=hXsG6S6yZXrr9thu3Uc-RQyl7MCaKayX1v9Ix9m7t50,271
-mm_eth/cli/cmd/deploy_cmd.py,sha256=H5p0K4p3wX9MGFHg-h__dYUw-X5ttNTEDMPCy_T5eHQ,1281
+mm_eth/cli/cmd/balances_cmd.py,sha256=4UiWSNH9OCnkvcMGPTygEss8119do-rfG7QtsNMfWZs,4197
+mm_eth/cli/cmd/call_contract_cmd.py,sha256=RbBPvyUEQ45hQINYDKkx1yWhPygdymVKlRL26xI31uk,1264
+mm_eth/cli/cmd/deploy_cmd.py,sha256=0oBp_RZw_DIEtBFRc6QKdAw5oouwwpDIdeXvuyP9xdU,1272
 mm_eth/cli/cmd/encode_input_data_cmd.py,sha256=9UQ1MKPEFQJ8j_COsP3KGKhwOf9tT3feBezI8vvxTlw,267
-mm_eth/cli/cmd/mnemonic_cmd.py,sha256=Mb0H0inSNCa93GEPxGYQi7BnPe11mnLjnspfe7h54I4,972
+mm_eth/cli/cmd/example_cmd.py,sha256=o4NTll3fjmspbKjZ0sHGDRHTZ1RcFNHZDi9Ka0VNoDQ,264
 mm_eth/cli/cmd/node_cmd.py,sha256=Ae5yPxxnNiHw3tZcojS7KwNLM4gEfLhsTfhZp_86rqU,1956
-mm_eth/cli/cmd/private_key_cmd.py,sha256=Fv_2OLog1h32pIP7PJITwl_pHdy3BXvaDRcXZsxY1xo,241
 mm_eth/cli/cmd/rpc_cmd.py,sha256=02q82YqgbPezfEBmV_QBCIeNReE7ktkPych8Xr9ann8,2186
-mm_eth/cli/cmd/send_contract_cmd.py,sha256=h4Ue2gU0SqMoqQk9L8gSOJyzGUgzNLk2fXkEwsTlgQE,7325
+mm_eth/cli/cmd/send_contract_cmd.py,sha256=JX3L1Dz4CBySfa2Pf87E8grauPu0U6xIyyOus81285Y,7316
 mm_eth/cli/cmd/solc_cmd.py,sha256=tBpeMdPfGs2iQIMaIJAAhMh1a3KyXHwyninfXPVpsgs,677
 mm_eth/cli/cmd/token_cmd.py,sha256=4y6ZQpLOJ33_iNuKpm9tZXh4RntWhmPUcizgaNNBzaw,1102
-mm_eth/cli/cmd/transfer_erc20_cmd.py,sha256=F9lUE4X_i4-yo4pdhHA3CWi1joHvtbUxyFUT4ibc574,7870
-mm_eth/cli/cmd/transfer_eth_cmd.py,sha256=egYx3yG29CCzKeZRzY5QmqSHQrypdHMKJ32rHdQpsyg,6980
+mm_eth/cli/cmd/transfer_cmd.py,sha256=nC1Jiqe6zDJQvK9xVhB8mCbkEB1ZgMZmA393tDnZ1Dw,12176
 mm_eth/cli/cmd/tx_cmd.py,sha256=PIenXYTT60Z2fqsivpzybCLI2Z_tlcz-asm3B0JLHgI,517
 mm_eth/cli/cmd/vault_cmd.py,sha256=MOM1CILIaaqown1I-Fgo22ckqIMLtFt8t2D3fWNp798,606
-mm_eth/cli/config_examples/balances.toml,sha256=Wb3y_-Rh5kqjEDX-jvRZhzwq_rVGv4zLKy7PGe1jysY,418
-mm_eth/cli/config_examples/call_contract.toml,sha256=vq6VtOlRYGWfLRpPXNkNcdQpndW8bJJRDBbrTr5rSt8,244
-mm_eth/cli/config_examples/transfer_erc20.toml,sha256=3bnLZbl49HlG0BFa4JLp0HQswNbr72BNBTa-niWsRGA,1135
-mm_eth/cli/config_examples/transfer_eth.toml,sha256=-eQEU9tK_4To_PDG39vvIZNkZhgh0_EZQJVjbUHJlyg,1164
-mm_eth-0.3.1.dist-info/METADATA,sha256=-sztCRTmBAWQ5dtkrzD167ZAwgM1WvZZr_Z2XBaKNqU,207
-mm_eth-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_eth-0.3.1.dist-info/entry_points.txt,sha256=aGhpsozl8NIrkuUcX5fSgURCcDhr3ShUdeTSIrJq4oc,46
-mm_eth-0.3.1.dist-info/RECORD,,
+mm_eth/cli/cmd/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/cmd/wallet/mnemonic_cmd.py,sha256=xE-5Ux9BdYsTZYBy0dMn9jupGhW4ced-AgYscy_wU_4,1007
+mm_eth/cli/cmd/wallet/private_key_cmd.py,sha256=Fv_2OLog1h32pIP7PJITwl_pHdy3BXvaDRcXZsxY1xo,241
+mm_eth/cli/examples/balances.toml,sha256=i_ALpiEcf8-0TFiUg1cgJhxxfHYeBl9x0b3tnUWjswU,421
+mm_eth/cli/examples/call_contract.toml,sha256=ZQWK-409V_vLIZ2bsRD5RCWPPzShPz2KJTTRQY4YaGw,248
+mm_eth/cli/examples/transfer.toml,sha256=HLVpkCNakZFE8qdFdDUoBPk7ZBdfEmk9TLZtooRsGAc,1198
+mm_eth-0.4.1.dist-info/METADATA,sha256=aMEeaP5awNBZ0ZhRIxmhTl1jennR_TAdETFamw4F9HU,207
+mm_eth-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_eth-0.4.1.dist-info/entry_points.txt,sha256=aGhpsozl8NIrkuUcX5fSgURCcDhr3ShUdeTSIrJq4oc,46
+mm_eth-0.4.1.dist-info/RECORD,,

mm_eth/cli/cmd/transfer_erc20_cmd.py

@@ -1,200 +0,0 @@
-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, Ok, fatal, utc_now
-from pydantic import AfterValidator, BeforeValidator, model_validator
-
-from mm_eth import erc20, rpc
-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
-from mm_eth.utils import from_wei_str
-
-
-# noinspection DuplicatedCode
-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, AfterValidator(Validators.eth_address())]
-    decimals: int
-    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_token_expression("balance"))]
-    value_min_limit: Annotated[str | None, AfterValidator(Validators.valid_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
-    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")
-
-        return self
-
-
-class TransferErc20CmdParams(BaseConfigParams):
-    print_balances: bool
-    debug: bool
-    no_receipt: bool
-    emulate: bool
-
-
-# noinspection DuplicatedCode
-def run(cli_params: TransferErc20CmdParams) -> 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)
-
-    # check decimals
-    res = erc20.get_decimals(config.nodes[0], config.token)
-    if isinstance(res, Err):
-        fatal(f"can't get token decimals: {res.err}")
-    if res.ok != config.decimals:
-        fatal(f"config.decimals is wrong: {config.decimals} != {res.ok}")
-
-    if cli_params.print_balances:
-        print_helpers.print_balances(
-            config.nodes,
-            config.from_addresses,
-            token_address=config.token,
-            token_decimals=config.decimals,
-            round_ndigits=config.round_ndigits,
-        )
-        sys.exit(0)
-
-    return _run_transfers(config, cli_params)
-
-
-# noinspection DuplicatedCode
-def _run_transfers(config: Config, cli_params: TransferErc20CmdParams) -> None:
-    logger.info(f"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, 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(route: TxRoute, config: Config, cli_params: TransferErc20CmdParams) -> None:
-    log_prefix = f"{route.from_address}->{route.to_address}"
-    # get nonce
-    nonce = rpc_helpers.get_nonce(config.nodes, route.from_address, log_prefix)
-    if nonce is None:
-        return
-
-    # 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_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_expression=config.gas,
-        from_address=route.from_address,
-        to_address=config.token,
-        data=erc20.encode_transfer_input_data(route.to_address, 1234),
-        log_prefix=log_prefix,
-    )
-    if gas is None:
-        return
-
-    # get value
-    value = 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.decimals,
-        log_prefix=log_prefix,
-    )
-    if value is None:
-        return
-
-    # value_min_limit
-    if config.value_min_limit is not None:
-        value_min_limit = mm_crypto_utils.calc_int_expression(config.value_min_limit, suffix_decimals={"t": config.decimals})
-        if value < value_min_limit:
-            value_str = from_wei_str(value, "t", config.round_ndigits, decimals=config.decimals)
-            logger.info(f"{log_prefix}value<value_min_limit, value={value_str}")
-            return
-
-    priority_fee = calc_eth_expression(config.priority_fee)
-
-    # emulate?
-    if cli_params.emulate:
-        msg = f"{log_prefix}: emulate,"
-        msg += f" value={from_wei_str(value, 't', decimals=config.decimals, round_ndigits=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
-
-    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 = 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,
-    )
-    res = rpc.eth_send_raw_transaction(config.nodes, signed_tx.raw_tx, attempts=5)
-    if isinstance(res, Err):
-        logger.info(f"{log_prefix}: send_error: {res.err}")
-        return
-    tx_hash = res.ok
-
-    if cli_params.no_receipt:
-        msg = f"{log_prefix}: tx_hash={tx_hash}, value={from_wei_str(value, 't', decimals=config.decimals, round_ndigits=config.round_ndigits)}"  # noqa: E501
-        logger.info(msg)
-    else:
-        logger.debug(f"{log_prefix}: tx_hash={tx_hash}, wait receipt")
-        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"
-                msg = f"{log_prefix}: tx_hash={tx_hash}, value={from_wei_str(value, 't', decimals=config.decimals, round_ndigits=config.round_ndigits)}, status={status}"  # noqa: E501
-                logger.info(msg)
-                break
-            time.sleep(1)

mm_eth/cli/cmd/transfer_eth_cmd.py

@@ -1,182 +0,0 @@
-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, Ok, utc_now
-from pydantic import AfterValidator, BeforeValidator, model_validator
-
-from mm_eth import rpc
-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):
-    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())]
-    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: Annotated[Path | None, AfterValidator(Validators.log_file())] = None
-    log_info: Annotated[Path | None, AfterValidator(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")
-
-        return self
-
-
-class TransferEthCmdParams(BaseConfigParams):
-    print_balances: bool
-    debug: bool
-    no_receipt: bool
-    emulate: bool
-
-
-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 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, cli_params)
-
-
-# noinspection DuplicatedCode
-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'}) | {'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(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, route.from_address, log_prefix)
-    if nonce is None:
-        return
-
-    # 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_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_expression=config.gas,
-        from_address=route.from_address,
-        to_address=route.to_address,
-        value=123,
-        log_prefix=log_prefix,
-    )
-    if gas is None:
-        return
-
-    # get value
-    value = 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=log_prefix,
-    )
-    if value is None:
-        return
-
-    # value_min_limit
-    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
-
-    priority_fee = calc_eth_expression(config.priority_fee)
-
-    # emulate?
-    if cli_params.emulate:
-        msg = f"{log_prefix}: emulate, value={from_wei_str(value, 'eth', 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
-
-    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,
-        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"{log_prefix}: send_error: {res.err}")
-        return
-    tx_hash = res.ok
-
-    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:  # 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"
-                msg = f"{log_prefix}: tx_hash={tx_hash}, value={from_wei_str(value, 'ether', round_ndigits=config.round_ndigits)}, status={status}"  # noqa: E501
-                logger.info(msg)
-                break
-            time.sleep(1)

mm_eth/cli/config_examples/transfer_eth.toml

@@ -1,26 +0,0 @@
-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
-"""