mm-eth 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

mm_eth/cli/cmd/deploy_cmd.py

@@ -0,0 +1,43 @@
+import sys
+from pathlib import Path
+
+import yaml
+from mm_std import BaseConfig, fatal, print_json
+from pydantic import StrictStr
+
+from mm_eth import account, deploy
+from mm_eth.cli import cli_utils, rpc_helpers
+
+
+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, Path(config_path))
+    if print_config:
+        print_json(config.model_dump(exclude={"private_key"}))
+        sys.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:
+        fatal("private address is wrong")
+
+    nonce = rpc_helpers.get_nonce(config.node, sender_address)
+    if nonce is None:
+        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,26 @@
+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:
+        data = [acc["address"] + "\t" + acc["private"] for acc in result["accounts"]]
+        Path(save_file).write_text("\n".join(data) + "\n")

mm_eth/cli/cmd/node_cmd.py

@@ -0,0 +1,47 @@
+from mm_std import Ok, PrintFormat, print_json, print_plain
+from rich.live import Live
+from rich.table import Table
+
+from mm_eth import rpc
+from mm_eth.utils import from_wei_str, name_network
+
+
+def run(urls: list[str], print_format: PrintFormat, proxy: str | None) -> None:
+    json_result: dict[str, object] = {}
+    table = Table(title="nodes")
+    if print_format == PrintFormat.TABLE:
+        table.add_column("url")
+        table.add_column("chain_id")
+        table.add_column("chain_name")
+        table.add_column("block_number")
+        table.add_column("base_fee")
+
+    with Live(table, refresh_per_second=0.5):
+        for url in urls:
+            chain_id_res = rpc.eth_chain_id(url, timeout=10, proxies=proxy)
+            chain_id = chain_id_res.ok_or_err()
+            chain_name = ""
+            if isinstance(chain_id_res, Ok):
+                chain_name = name_network(chain_id_res.ok)
+            block_number = rpc.eth_block_number(url, timeout=10, proxies=proxy).ok_or_err()
+            base_fee = rpc.get_base_fee_per_gas(url, timeout=10, proxies=proxy).map_or_else(
+                lambda err: err,
+                lambda ok: from_wei_str(ok, "gwei"),
+            )
+
+            json_result[url] = {
+                "chain_id": chain_id,
+                "chain_name": chain_name,
+                "block_number": block_number,
+                "base_fee": base_fee,
+            }
+            if print_format == PrintFormat.TABLE:
+                table.add_row(url, str(chain_id), chain_name, str(block_number), base_fee)
+            print_plain(f"url: {url}", print_format)
+            print_plain(f"chain_id: {chain_id}", print_format)
+            print_plain(f"chain_name: {chain_name}", print_format)
+            print_plain(f"block_number: {block_number}", print_format)
+            print_plain(f"base_fee: {base_fee}", print_format)
+            print_plain("", print_format)
+
+    print_json(json_result, print_format)

mm_eth/cli/cmd/private_key_cmd.py

@@ -0,0 +1,10 @@
+from mm_std import fatal, print_plain
+
+from mm_eth import account
+
+
+def run(private_key: str) -> None:
+    try:
+        print_plain(account.private_to_address(private_key))
+    except Exception as e:
+        fatal(f"wrong private key: {e}")

mm_eth/cli/cmd/rpc_cmd.py

@@ -0,0 +1,78 @@
+import json
+from typing import cast
+
+from mm_std import fatal, hr, print_console, str_starts_with_any
+from rich import print_json
+
+from mm_eth.cli.cli_utils import public_rpc_url
+
+
+def run(rpc_url: str, method: str, params: str, hex2dec: bool) -> None:
+    rpc_url = public_rpc_url(rpc_url)
+    if not method:
+        return list_all_methods()
+    if not str_starts_with_any(rpc_url, ["http://", "https://"]):
+        fatal(f"invalid rpc_url: {rpc_url}")
+    params = params.replace("'", '"')
+    data = {"jsonrpc": "2.0", "method": method, "params": parse_method_params(method, params), "id": 1}
+    res = hr(rpc_url, method="POST", params=data, json_params=True)
+    if res.json:
+        print_json(data=res.json)
+        result_value: str = res.json.get("result", "")
+        if hex2dec and result_value.startswith(("0x", "0X")):
+            print_console("hex2dec", int(result_value, 16))
+    else:
+        fatal(str(res))
+
+
+def parse_method_params(method: str, params_str: str) -> list[object]:
+    params = json.loads(params_str) if params_str.startswith("[") else params_str.split()
+    if method in ["eth_getBalance", "eth_getTransactionCount", "eth_getCode"] and len(params) == 1:
+        params.append("latest")
+    return cast(list[object], params)
+
+
+def list_all_methods() -> None:
+    all_methods = """
+web3_clientVersion
+web3_sha3
+net_version
+net_listening
+net_peerCount
+eth_protocolVersion
+eth_syncing
+eth_chainId
+eth_gasPrice
+eth_accounts
+eth_blockNumber
+eth_getBalance
+eth_getStorageAt
+eth_getTransactionCount
+eth_getBlockTransactionCountByHash
+eth_getBlockTransactionCountByNumber
+eth_getUncleCountByBlockHash
+eth_getUncleCountByBlockNumber
+eth_getCode
+eth_sign
+eth_signTransaction
+eth_sendTransaction
+eth_sendRawTransaction
+eth_call
+eth_estimateGas
+eth_getBlockByHash
+eth_getBlockByNumber
+eth_getTransactionByHash
+eth_getTransactionByBlockHashAndIndex
+eth_getTransactionByBlockNumberAndIndex
+eth_getTransactionReceipt
+eth_getUncleByBlockHashAndIndex
+eth_getUncleByBlockNumberAndIndex
+eth_newFilter
+eth_newBlockFilter
+eth_newPendingTransactionFilter
+eth_uninstallFilter
+eth_getFilterChanges
+eth_getFilterLogs
+eth_getLogs
+    """.strip()
+    print_console(all_methods)

mm_eth/cli/cmd/send_contract_cmd.py

@@ -0,0 +1,251 @@
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Self
+
+from loguru import logger
+from mm_std import BaseConfig, Err, Ok, print_json, str_to_list, utc_now
+from pydantic import Field, StrictStr, field_validator, 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.tx import sign_tx
+from mm_eth.utils import from_wei_str
+
+
+class Config(BaseConfig):
+    contract_address: str
+    function_signature: str
+    function_args: StrictStr = "[]"
+    nodes: list[StrictStr]
+    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
+    round_ndigits: int = 5
+    log_debug: str | None = None
+    log_info: str | None = None
+
+    @field_validator("log_debug", "log_info", mode="before")
+    @classmethod
+    def log_validator(cls, v: str | None) -> str | None:
+        return validators.log_validator(v)
+
+    @field_validator("nodes", "from_addresses", mode="before")
+    @classmethod
+    def list_validator(cls, v: str | list[str] | None) -> list[str]:
+        return validators.nodes_validator(v)
+
+    @field_validator("from_addresses", mode="before")
+    @classmethod
+    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")
+    @classmethod
+    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)
+
+    # 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 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}")
+
+        return self
+
+
+# noinspection DuplicatedCode
+def run(
+    config_path: str,
+    *,
+    print_balances: bool,
+    print_config: bool,
+    debug: bool,
+    no_receipt: bool,
+    emulate: bool,
+) -> None:
+    config = cli_utils.read_config(Config, Path(config_path))
+    if print_config:
+        print_json(config.model_dump(exclude={"private_key"}))
+        sys.exit(0)
+
+    cli_utils.init_logger(debug, config.log_debug, config.log_info)
+    rpc_helpers.check_nodes_for_chain_id(config.nodes, config.chain_id)
+
+    if 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)
+
+
+# noinspection DuplicatedCode
+def _run_transfers(config: Config, *, no_receipt: bool, emulate: bool) -> 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)
+            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:
+    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:
+        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):
+        return
+
+    max_priority_fee_per_gas = calcs.calc_var_wei_value(config.max_priority_fee_per_gas)
+
+    # data
+    function_args = calcs.calc_function_args(config.function_args).replace("'", '"')
+    data = abi.encode_function_input_by_signature(config.function_signature, json.loads(function_args))
+
+    # get gas
+    gas = rpc_helpers.calc_gas(
+        nodes=config.nodes,
+        gas=config.gas,
+        from_address=from_address,
+        to_address=config.contract_address,
+        value=None,
+        data=data,
+        log_prefix=log_prefix,
+    )
+    if gas is None:
+        return
+
+    # get value
+    value = None
+    if config.value is not None:
+        value = rpc_helpers.calc_eth_value(
+            nodes=config.nodes,
+            value_str=config.value,
+            address=from_address,
+            gas=gas,
+            max_fee_per_gas=max_fee_per_gas,
+            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:
+        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}"
+        logger.info(msg)
+        return
+
+    logger.debug(f"{log_prefix}: tx_params={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,
+        gas=gas,
+        private_key=config.private_keys[from_address],
+        chain_id=config.chain_id,
+        value=value,
+        data=data,
+        to=config.contract_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 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:
+            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}, status={status}"
+                logger.info(msg)
+                break
+            time.sleep(1)

mm_eth/cli/cmd/solc_cmd.py

@@ -0,0 +1,24 @@
+import json
+
+from mm_std import Err, PrintFormat, fatal, print_json, print_plain
+from mm_std.fs import get_filename_without_extension
+
+from mm_eth.solc import solc
+
+
+def run(contract_path: str, tmp_dir: str, print_format: PrintFormat) -> None:
+    contract_name = get_filename_without_extension(contract_path)
+    res = solc(contract_name, contract_path, tmp_dir)
+    if isinstance(res, Err):
+        fatal(res.err)
+
+    bin_ = res.ok.bin
+    abi = res.ok.abi
+
+    if print_format == PrintFormat.JSON:
+        print_json({"bin": bin_, "abi": json.loads(abi)})
+    else:
+        print_plain("bin:")
+        print_plain(bin_)
+        print_plain("abi:")
+        print_plain(abi)

mm_eth/cli/cmd/token_cmd.py

@@ -0,0 +1,29 @@
+from mm_std import Err, Ok, print_plain
+
+from mm_eth import erc20, rpc
+from mm_eth.cli import cli_utils
+
+
+def run(rpc_url: str, token_address: str) -> None:
+    rpc_url = cli_utils.public_rpc_url(rpc_url)
+    name = erc20.get_name(rpc_url, token_address).ok_or_err()
+    symbol = erc20.get_symbol(rpc_url, token_address).ok_or_err()
+    decimals = erc20.get_decimals(rpc_url, token_address).ok_or_err()
+    transfer_count = _calc_transfer_events(rpc_url, 100, token_address)
+
+    print_plain(f"name: {name}")
+    print_plain(f"symbol: {symbol}")
+    print_plain(f"decimals: {decimals}")
+    print_plain(f"transfer_count: {transfer_count}")
+
+
+def _calc_transfer_events(rpc_url: str, last_block_limit: int, token_address: str) -> int | str:
+    current_block_res = rpc.eth_block_number(rpc_url)
+    if isinstance(current_block_res, Err):
+        return current_block_res.err
+    current_block = current_block_res.ok
+
+    res = erc20.get_transfer_event_logs(rpc_url, token_address, current_block - last_block_limit, current_block)
+    if isinstance(res, Ok):
+        return len(res.ok)
+    return res.err