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

mm_eth/cli/cmd/balance_cmd.py

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

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

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

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

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

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

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

mm_eth/cli/cmd/node_cmd.py

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

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

@@ -1,81 +0,0 @@
-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]:
-    if params_str.startswith("["):
-        params = json.loads(params_str)
-    else:
-        params = 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)