mm-eth 0.1.0__py3-none-any.whl

mm_eth/cli/cli_helpers.py

@@ -0,0 +1,195 @@
+import importlib.metadata
+import sys
+from typing import NoReturn
+
+from loguru import logger
+from mm_std import Err
+from rich.live import Live
+from rich.table import Table
+
+from mm_eth import erc20, rpc
+from mm_eth.cli import calcs
+from mm_eth.utils import from_wei_str
+
+
+def get_nonce(nodes: list[str] | str, address: str, log_prefix: str | None = None) -> int | None:
+    res = rpc.eth_get_transaction_count(nodes, address, attempts=5)
+    prefix = log_prefix or address
+    logger.debug(f"{prefix}: nonce={res.ok_or_err()}")
+    if isinstance(res, Err):
+        logger.info(f"{prefix}: nonce error, {res.err}")
+        return None
+    return res.ok
+
+
+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)
+    logger.debug(f"{prefix}base_fee={res.ok_or_err()}")
+    if isinstance(res, Err):
+        logger.info(f"{prefix}base_fee error, {res.err}")
+        return 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():
+        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)
+
+
+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:
+        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)
+        logger.info(
+            "{}max_fee_per_gas_limit is exeeded, max_fee_per_gas={}, max_fee_per_gas_limit={}",
+            prefix,
+            from_wei_str(max_fee_per_gas, "gwei"),
+            from_wei_str(max_fee_per_gas_limit_value, "gwei"),
+        )
+        return True
+    return False
+
+
+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 < calcs.calc_var_wei_value(value_min_limit, decimals=decimals):
+        prefix = _get_prefix(log_prefix)
+        logger.info("{}value is less min limit, value={}", prefix, from_wei_str(value, value_unit, decimals=decimals))
+        return True
+    return False
+
+
+def calc_gas(
+    *,
+    nodes: list[str],
+    gas: 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)
+        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)
+
+
+def calc_eth_value(
+    *,
+    nodes: list[str],
+    value_str: str,
+    address: str,
+    gas: int | None = None,
+    max_fee_per_gas: int | None = None,
+    log_prefix: str | None = None,
+) -> int | None:
+    balance_value = None
+    if "balance" in value_str.lower():
+        prefix = _get_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
+    return value
+
+
+def calc_erc20_value(
+    *,
+    nodes: list[str],
+    value_str: 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)
+        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 print_balances(
+    rpc_nodes: list[str],
+    addresses: list[str],
+    *,
+    token_address: str | None = None,
+    token_decimals: int | None = None,
+    round_ndigits: int = 5,
+) -> None:
+    table = Table(title="balances")
+    table.add_column("n")
+    table.add_column("address")
+    table.add_column("nonce")
+    table.add_column("balance, eth")
+    if token_address is not None and token_decimals is not None:
+        table.add_column("token, t")
+    with Live(table, refresh_per_second=0.5):
+        count = 0
+        for address in addresses:
+            count += 1
+            nonce = str(rpc.eth_get_transaction_count(rpc_nodes, address, attempts=5).ok_or_err())
+            balance = rpc.eth_get_balance(rpc_nodes, address, attempts=5).map_or_else(
+                lambda err: err,
+                lambda ok: from_wei_str(ok, "eth", round_ndigits),
+            )
+            row: list[str] = [str(count), address, nonce, balance]
+            if token_address is not None and token_decimals is not None:
+                erc20_balance = erc20.get_balance(rpc_nodes, token_address, address, attempts=5).map_or_else(
+                    lambda err: err,
+                    lambda ok: from_wei_str(ok, "t", decimals=token_decimals, round_ndigits=round_ndigits),
+                )
+                row.append(erc20_balance)
+            table.add_row(*row)
+
+
+def fatal(message: str) -> NoReturn:
+    print(f"error: {message}", file=sys.stderr)  # noqa: T201
+    sys.exit(1)
+
+
+def get_version() -> str:
+    return importlib.metadata.version("mm-eth")
+
+
+def _get_prefix(log_prefix: str | None) -> str:
+    prefix = log_prefix or ""
+    if prefix:
+        prefix += ": "
+    return prefix

mm_eth/cli/cli_utils.py

@@ -0,0 +1,150 @@
+import sys
+import time
+from pathlib import Path
+from typing import TypeVar
+
+import eth_utils
+import yaml
+from loguru import logger
+from mm_std import Err, fatal, str_to_list, utc_now
+from pydantic import BaseModel, ConfigDict, ValidationError
+from rich.console import Console
+from rich.table import Table
+
+from mm_eth import account, rpc
+from mm_eth.account import is_private_key
+from mm_eth.cli import calcs
+
+
+class BaseConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+def check_nodes_for_chain_id(nodes: list[str], chain_id: int) -> None:
+    for node in nodes:
+        res = rpc.eth_chain_id(node, timeout=7)
+        if isinstance(res, Err):
+            fatal(f"can't get chain_id for {node}, error={res.err}")
+        if res.ok != chain_id:
+            fatal(f"node {node} has a wrong chain_id: {res.ok}")
+
+
+def check_private_keys(addresses: list[str], private_keys: dict[str, str]) -> None:
+    for address in addresses:
+        address = address.lower()
+        if address not in private_keys:
+            fatal(f"no private key for {address}")
+        if account.private_to_address(private_keys[address]) != address:
+            fatal(f"no private key for {address}")
+
+
+def delay(value: str | None) -> None:
+    if value is None:
+        return
+    time.sleep(float(calcs.calc_decimal_value(value)))
+
+
+T = TypeVar("T")
+
+
+def read_config(config_cls: type[T], config_path: str) -> T:
+    try:
+        with open(config_path) as f:
+            config = config_cls(**yaml.full_load(f))
+            return config
+    except ValidationError as err:
+        table = Table(title="config validation errors")
+        table.add_column("field")
+        table.add_column("message")
+        for e in err.errors():
+            loc = e["loc"]
+            field = str(loc[0]) if len(loc) > 0 else ""
+            table.add_row(field, e["msg"])
+        console = Console()
+        console.print(table)
+        exit(1)
+
+
+def log(log_path: str | None, *messages: object) -> None:
+    if log_path is None:
+        return
+    message = ", ".join([str(m) for m in messages])
+    message = f"{utc_now()}, {message}\n"
+    with open(Path(log_path).expanduser(), "a") as f:
+        f.write(message)
+
+
+def load_tx_addresses_from_str(v: str | None) -> list[tuple[str, str]]:
+    result: list[tuple[str, str]] = []
+    if v is None:
+        return result
+    for line in str_to_list(v, remove_comments=True):
+        arr = line.split()
+        if len(arr) == 2 and eth_utils.is_address(arr[0]) and eth_utils.is_address(arr[1]):
+            result.append((arr[0].lower(), arr[1].lower()))
+    return result
+
+
+def load_tx_addresses_from_files(addresses_from_file: str, addresses_to_file: str) -> list[tuple[str, str]]:
+    from_file = Path(addresses_from_file).expanduser()
+    to_file = Path(addresses_to_file).expanduser()
+    if not from_file.is_file():
+        raise ValueError(f"can't read addresses from 'addresses_from_file={addresses_from_file}")
+    if not to_file.is_file():
+        raise ValueError(f"can't read addresses from 'addresses_to_file={addresses_to_file}")
+
+    # get addresses_from
+    addresses_from = []
+    for line in from_file.read_text().strip().split("\n"):
+        if not eth_utils.is_address(line):
+            raise ValueError(f"illigal address in addresses_from_file: {line}")
+        addresses_from.append(line.lower())
+
+    # get addresses_to
+    addresses_to = []
+    for line in to_file.read_text().strip().split("\n"):
+        if not eth_utils.is_address(line):
+            raise ValueError(f"illigal address in addresses_to_file: {line}")
+        addresses_to.append(line.lower())
+
+    if len(addresses_from) != len(addresses_to):
+        raise ValueError("len(addresses_from) != len(addresses_to)")
+
+    return list(zip(addresses_from, addresses_to, strict=True))
+
+
+def load_private_keys_from_file(private_keys_file: str) -> list[str]:
+    result: list[str] = []
+    for item in Path(private_keys_file).expanduser().read_text().split():
+        if is_private_key(item):
+            result.append(item)
+    return result
+
+
+def init_logger(debug: bool, log_debug_file: str | None, log_info_file: str | None) -> None:
+    if debug:
+        level = "DEBUG"
+        format_ = "<green>{time:YYYY-MM-DD HH:mm:ss}</green> <level>{level}</level> {message}"
+    else:
+        level = "INFO"
+        format_ = "{message}"
+
+    logger.remove()
+    logger.add(sys.stderr, format=format_, colorize=True, level=level)
+    if log_debug_file:
+        logger.add(Path(log_debug_file).expanduser(), format="{time:YYYY-MM-DD HH:mm:ss} {level} {message}")
+    if log_info_file:
+        logger.add(Path(log_info_file).expanduser(), format="{message}", level="INFO")
+
+
+def public_rpc_url(url: str | None) -> str:
+    if not url or url == "1":
+        return "https://ethereum.publicnode.com"
+    if url.startswith(("http://", "https://", "ws://", "wss://")):
+        return url
+
+    match url.lower():
+        case "opbnb" | "204":
+            return "https://opbnb-mainnet-rpc.bnbchain.org"
+        case _:
+            return url

mm_eth/cli/cmd/balance_cmd.py

@@ -0,0 +1,59 @@
+from mm_std import Err, Ok, print_json, print_plain
+
+from mm_eth import erc20, rpc
+from mm_eth.cli import cli_helpers
+from mm_eth.cli.cli import PrintFormat
+from mm_eth.cli.cli_utils import public_rpc_url
+from mm_eth.utils import from_wei_str
+
+
+def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool, print_format: PrintFormat) -> None:
+    rpc_url = public_rpc_url(rpc_url)
+    json_result: dict[str, object] = {}
+
+    # nonce
+    nonce = rpc.eth_get_transaction_count(rpc_url, wallet_address).ok_or_err()
+    print_plain(f"nonce: {nonce}", print_format)
+    json_result["nonce"] = nonce
+
+    # balance
+    balance_res = rpc.eth_get_balance(rpc_url, wallet_address)
+    if isinstance(balance_res, Ok):
+        if wei:
+            balance = str(balance_res.ok)
+        else:
+            balance = from_wei_str(balance_res.ok, "eth")
+    else:
+        balance = balance_res.err
+    print_plain(f"eth_balance: {balance}", print_format)
+    json_result["eth_balance"] = balance
+
+    if token_address is not None:
+        # token decimal
+        decimals_res = erc20.get_decimals(rpc_url, token_address)
+        if isinstance(decimals_res, Err):
+            cli_helpers.fatal(f"can't get token decimals: {decimals_res.err}")
+        decimals = decimals_res.ok
+        print_plain(f"token_decimal: {decimals}", print_format)
+        json_result["token_decimal"] = decimals
+
+        # token symbol
+        symbol_res = erc20.get_symbol(rpc_url, token_address)
+        if isinstance(symbol_res, Err):
+            cli_helpers.fatal(f"can't get token symbol: {symbol_res.err}")
+        symbol = symbol_res.ok
+        print_plain(f"token_symbol: {symbol}", print_format)
+        json_result["token_symbol"] = symbol
+
+        # token balance
+        balance_res = erc20.get_balance(rpc_url, token_address, wallet_address)
+        if isinstance(balance_res, Err):
+            cli_helpers.fatal(f"can't get token balance: {balance_res.err}")
+        if wei:
+            balance = str(balance_res.ok)
+        else:
+            balance = from_wei_str(balance_res.ok, "t", decimals=decimals)
+        print_plain(f"token_balance: {balance}", print_format)
+        json_result["token_balance"] = balance
+
+    print_json(json_result, print_format)

mm_eth/cli/cmd/balances_cmd.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+
+from mm_std import Err, Ok, fatal, json_dumps
+from pydantic import BaseModel, Field, field_validator
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+
+from mm_eth import erc20, rpc
+from mm_eth.cli import cli_utils, validators
+from mm_eth.utils import from_token_wei_str, from_wei_str
+
+
+class Config(BaseModel):
+    addresses: list[str]
+    tokens: list[str] = Field(default_factory=list)
+    nodes: list[str]
+    round_ndigits: int = 5
+
+    @field_validator("nodes", mode="before")
+    def nodes_validator(cls, v: str | list[str] | None) -> list[str]:
+        return validators.nodes_validator(v)
+
+    @field_validator("tokens", "addresses", mode="before")
+    def addresses_validator(cls, v: str | list[str] | None) -> list[str]:
+        return validators.addresses_validator(v)
+
+
+@dataclass
+class Token:
+    address: str
+    decimals: int
+    symbol: str
+
+
+def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> None:
+    config = cli_utils.read_config(Config, config_path)
+    if print_config:
+        console = Console()
+        console.print_json(json_dumps(config.model_dump()))
+        exit(0)
+
+    tokens = _get_tokens_info(config)
+
+    table = Table(title="balances")
+    table.add_column("address")
+    if show_nonce:
+        table.add_column("nonce")
+    table.add_column("wei" if wei else "eth")
+    for t in tokens:
+        table.add_column(t.symbol)
+
+    base_sum = 0
+    token_sum: dict[str, int] = {t.address: 0 for t in tokens}
+    with Live(table, refresh_per_second=0.5):
+        for address in config.addresses:
+            row = [address]
+            if show_nonce:
+                row.append(str(rpc.eth_get_transaction_count(config.nodes, address, attempts=5).ok_or_err()))
+
+            base_balance_res = rpc.eth_get_balance(config.nodes, address, attempts=5)
+            if isinstance(base_balance_res, Ok):
+                base_sum += base_balance_res.ok
+                if wei:
+                    row.append(str(base_balance_res.ok))
+                else:
+                    row.append(
+                        from_wei_str(base_balance_res.ok, "eth", round_ndigits=config.round_ndigits, print_unit_name=False),
+                    )
+            else:
+                row.append(base_balance_res.err)
+
+            for t in tokens:
+                token_balance_res = erc20.get_balance(config.nodes, t.address, address, attempts=5)
+                if isinstance(token_balance_res, Ok):
+                    token_sum[t.address] += token_balance_res.ok
+                    if wei:
+                        row.append(str(token_balance_res.ok))
+                    else:
+                        row.append(
+                            from_token_wei_str(
+                                token_balance_res.ok,
+                                decimals=t.decimals,
+                                round_ndigits=config.round_ndigits,
+                            ),
+                        )
+                else:
+                    row.append(token_balance_res.err)
+
+            table.add_row(*row)
+
+        sum_row = ["sum"]
+        if show_nonce:
+            sum_row.append("")
+        if wei:
+            sum_row.append(str(base_sum))
+            for t in tokens:
+                sum_row.append(str(token_sum[t.address]))
+        else:
+            sum_row.append(from_wei_str(base_sum, "eth", round_ndigits=config.round_ndigits, print_unit_name=False))
+            for t in tokens:
+                sum_row.append(from_token_wei_str(token_sum[t.address], t.decimals, round_ndigits=config.round_ndigits))
+        table.add_row(*sum_row)
+
+
+def _get_tokens_info(config: Config) -> list[Token]:
+    result: list[Token] = []
+    for address in config.tokens:
+        decimals_res = erc20.get_decimals(config.nodes, address, attempts=5)
+        if isinstance(decimals_res, Err):
+            fatal(f"can't get token {address} decimals: {decimals_res.err}")
+        decimal = decimals_res.ok
+
+        symbols_res = erc20.get_symbol(config.nodes, address, attempts=5)
+        if isinstance(symbols_res, Err):
+            fatal(f"can't get token {address} symbol: {symbols_res.err}")
+        symbol = symbols_res.ok
+
+        result.append(Token(address=address, decimals=decimal, symbol=symbol))
+
+    return result

mm_eth/cli/cmd/call_contract_cmd.py

@@ -0,0 +1,44 @@
+import json
+from logging import fatal
+
+from mm_std import Err, print_json, print_plain
+from pydantic import StrictStr
+
+from mm_eth import abi, rpc
+from mm_eth.cli import cli_utils
+
+
+class Config(cli_utils.BaseConfig):
+    contract_address: StrictStr
+    function_signature: str
+    function_args: StrictStr = "[]"
+    outputs_types: str | None = None
+    node: str
+
+
+def run(config_path: str, print_config: bool) -> None:
+    config = cli_utils.read_config(Config, config_path)
+    if print_config:
+        print_json(config.model_dump())
+        exit(0)
+
+    input_data = abi.encode_function_input_by_signature(
+        config.function_signature,
+        json.loads(config.function_args.replace("'", '"')),
+    )
+    res = rpc.eth_call(config.node, config.contract_address, input_data)
+    if isinstance(res, Err):
+        return fatal(f"error: {res.err}")
+
+    result = res.ok
+    if config.outputs_types is not None:
+        decode_res = abi.decode_data(_get_types(config.outputs_types), result)
+        if len(decode_res) == 1:
+            result = decode_res[0]
+        else:
+            result = str(decode_res)
+    print_plain(result)
+
+
+def _get_types(data: str) -> list[str]:
+    return [t.strip() for t in data.split(",") if t.strip()]

mm_eth/cli/cmd/config_example_cmd.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+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")
+    print_plain(example_file.read_text())

mm_eth/cli/cmd/deploy_cmd.py

@@ -0,0 +1,41 @@
+import yaml
+from mm_std import print_json
+from pydantic import StrictStr
+
+from mm_eth import account, deploy
+from mm_eth.cli import cli_helpers, cli_utils
+from mm_eth.cli.cli_utils import BaseConfig
+
+
+class Config(BaseConfig):
+    private_key: StrictStr
+    nonce: int | None = None
+    gas: StrictStr
+    max_fee_per_gas: str
+    max_priority_fee_per_gas: str
+    value: str | None = None
+    contract_bin: StrictStr
+    constructor_types: StrictStr = "[]"
+    constructor_values: StrictStr = "[]"
+    chain_id: int
+    node: str
+
+
+def run(config_path: str, *, print_config: bool) -> None:
+    config = cli_utils.read_config(Config, config_path)
+    if print_config:
+        print_json(config.model_dump(exclude={"private_key"}))
+        exit(0)
+
+    constructor_types = yaml.full_load(config.constructor_types)
+    constructor_values = yaml.full_load(config.constructor_values)
+
+    sender_address = account.private_to_address(config.private_key)
+    if sender_address is None:
+        cli_utils.fatal("private address is wrong")
+
+    nonce = cli_helpers.get_nonce(config.node, sender_address)
+    if nonce is None:
+        cli_utils.fatal("can't get nonce")
+
+    deploy.get_deploy_contract_data(config.contract_bin, constructor_types, constructor_values)

mm_eth/cli/cmd/encode_input_data_cmd.py

@@ -0,0 +1,10 @@
+import json
+
+from mm_std import print_plain
+
+from mm_eth import abi
+
+
+def run(function_signature: str, args_str: str) -> None:
+    args_str = args_str.replace("'", '"')
+    print_plain(abi.encode_function_input_by_signature(function_signature, json.loads(args_str)))

mm_eth/cli/cmd/mnemonic_cmd.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+from typing import Any
+
+from mm_std import print_json
+
+from mm_eth.account import generate_accounts, generate_mnemonic
+
+
+def run(mnemonic: str, passphrase: str, limit: int, print_path: bool, path_prefix: str, save_file: str) -> None:  # nosec
+    result: dict[str, Any] = {}
+    if not mnemonic:
+        mnemonic = generate_mnemonic()
+    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):
+        new_account = {"address": acc.address, "private": acc.private_key}
+        if print_path:
+            new_account["path"] = acc.path
+        result["accounts"].append(new_account)
+    print_json(result)
+
+    if save_file:
+        with open(Path(save_file).expanduser(), "w") as f:
+            for account in result["accounts"]:
+                f.write(f"{account['address']}\t{account['private']}\n")