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

mm_eth/cli/cmd/config_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}.yml")
+    example_file = Path(Path(__file__).parent.absolute(), "../config_examples", f"{command}.toml")
     print_plain(example_file.read_text())

mm_eth/cli/cmd/deploy_cmd.py

@@ -3,7 +3,8 @@ from mm_std import BaseConfig, fatal
 from pydantic import StrictStr
 
 from mm_eth import account, deploy
-from mm_eth.cli import cli_utils, rpc_helpers
+from mm_eth.cli import rpc_helpers
+from mm_eth.cli.cli_utils import BaseConfigParams
 
 
 class Config(BaseConfig):
@@ -20,9 +21,14 @@ class Config(BaseConfig):
     node: str
 
 
-def run(config_path: str, *, print_config: bool) -> None:
-    config = Config.read_config_or_exit(config_path)
-    cli_utils.print_config_and_exit(print_config, config, {"private_key"})
+class DeployCmdParams(BaseConfigParams):
+    pass
+
+
+def run(cli_params: DeployCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(cli_params.config_path)
+    if cli_params.print_config_and_exit:
+        config.print_and_exit({"private_key"})
 
     constructor_types = yaml.full_load(config.constructor_types)
     constructor_values = yaml.full_load(config.constructor_values)

mm_eth/cli/cmd/node_cmd.py

@@ -44,4 +44,4 @@ def run(urls: list[str], print_format: PrintFormat, proxy: str | None) -> None:
             print_plain(f"base_fee: {base_fee}", print_format)
             print_plain("", print_format)
 
-    print_json(json_result, print_format)
+    print_json(json_result, print_format=print_format)

mm_eth/cli/cmd/send_contract_cmd.py

@@ -2,101 +2,52 @@ import json
 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
+from mm_std import BaseConfig, Err, Ok, utc_now
+from pydantic import AfterValidator, BeforeValidator, StrictStr, model_validator
 
 from mm_eth import abi, 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.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):
-    contract_address: str
+    from_addresses: Annotated[list[str], BeforeValidator(Validators.eth_addresses(unique=True))]
+    contract_address: Annotated[str, BeforeValidator(Validators.eth_address())]
     function_signature: str
     function_args: StrictStr = "[]"
-    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 | None = None
-    gas: str
-    from_addresses: list[str]
-    delay: str | None = None  # in seconds
+    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"))]  # eth value
+    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
-
-    @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", "from_addresses", mode="before")
-    def list_validator(cls, v: str | list[str] | None) -> list[str]:
-        return validators.nodes_validator(v)
-
-    @field_validator("from_addresses", mode="before")
-    def from_addresses_validator(cls, v: str | list[str] | None) -> list[str]:
-        return str_to_list(v, remove_comments=True, lower=True)
-
-    @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)
+    log_debug: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
+    log_info: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
 
     # 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
+        # check all private keys exist
+        if not self.private_keys.contains_all_addresses(self.from_addresses):
+            raise ValueError("private keys are not set for all addresses")
 
         # check that from_addresses is not empty
         if not self.from_addresses:
             raise ValueError("from_addresses is empty")
 
-        # 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 self.value is not None and not validators.is_valid_calc_var_wei_value(self.value, "balance"):
-            raise ValueError(f"wrong value: {self.value}")
-
-        # 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}")
-
         # function_args
         if not validators.is_valid_calc_function_args(self.function_args):
             raise ValueError(f"wrong function_args: {self.function_args}")
@@ -104,61 +55,61 @@ class Config(BaseConfig):
         return self
 
 
+class SendContractCmdParams(BaseConfigParams):
+    print_balances: bool
+    debug: bool
+    no_receipt: bool
+    emulate: bool
+
+
 # noinspection DuplicatedCode
-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"})
-
-    cli_utils.init_logger(debug, config.log_debug, config.log_info)
+def run(cli_params: SendContractCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(cli_params.config_path)
+    if cli_params.print_config_and_exit:
+        config.print_and_exit({"private_key"})
+
+    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)
 
-    _run_transfers(config, no_receipt=no_receipt, emulate=emulate)
+    _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: SendContractCmdParams) -> None:
     logger.info(f"started at {utc_now()} UTC")
     logger.debug(f"config={config.model_dump(exclude={'private_keys'}) | {'version': cli_utils.get_version()}}")
-    cli_utils.check_private_keys(config.from_addresses, config.private_keys)
     for i, from_address in enumerate(config.from_addresses):
-        _transfer(from_address=from_address, config=config, no_receipt=no_receipt, emulate=emulate)
-        if not emulate and config.delay is not None and i < len(config.from_addresses) - 1:
-            delay_value = calcs.calc_decimal_value(config.delay)
+        _transfer(from_address, config, cli_params)
+        if not cli_params.emulate and config.delay is not None and i < len(config.from_addresses) - 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, config: Config, no_receipt: bool, emulate: bool) -> None:
+def _transfer(from_address: str, config: Config, cli_params: SendContractCmdParams) -> None:
     log_prefix = f"{from_address}"
     # get nonce
     nonce = rpc_helpers.get_nonce(config.nodes, 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
 
-    max_priority_fee_per_gas = calcs.calc_var_wei_value(config.max_priority_fee_per_gas)
+    priority_fee = calc_eth_expression(config.priority_fee)
 
     # data
     function_args = calcs.calc_function_args(config.function_args).replace("'", '"')
@@ -167,7 +118,7 @@ def _transfer(*, from_address: str, config: Config, no_receipt: bool, emulate: b
     # get gas
     gas = rpc_helpers.calc_gas(
         nodes=config.nodes,
-        gas=config.gas,
+        gas_expression=config.gas,
         from_address=from_address,
         to_address=config.contract_address,
         value=None,
@@ -180,43 +131,44 @@ def _transfer(*, from_address: str, config: Config, no_receipt: bool, emulate: b
     # get value
     value = None
     if config.value is not None:
-        value = rpc_helpers.calc_eth_value(
+        value = rpc_helpers.calc_eth_value_for_address(
             nodes=config.nodes,
-            value_str=config.value,
+            value_expression=config.value,
             address=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
 
-    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": config.contract_address,
-        "chain_id": config.chain_id,
-    }
-
     # emulate?
-    if emulate:
+    if cli_params.emulate:
         msg = f"{log_prefix}: emulate,"
         if value is not None:
             msg += f" 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" gas={gas}"
+        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}, "
+        msg += f" data={data}"
         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,
+        "data": data,
+        "to": config.contract_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],
         chain_id=config.chain_id,
@@ -230,12 +182,12 @@ def _transfer(*, from_address: str, config: Config, no_receipt: bool, emulate: b
         return
     tx_hash = res.ok
 
-    if no_receipt:
+    if cli_params.no_receipt:
         msg = f"{log_prefix}: tx_hash={tx_hash}"
         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"