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

mm_eth/cli/calcs.py

@@ -1,88 +0,0 @@
-import random
-from decimal import Decimal
-
-from mm_std.random_ import random_decimal
-from mm_std.str import split_on_plus_minus_tokens
-
-from mm_eth.utils import to_wei
-
-
-def calc_var_wei_value(value: str, *, var_name: str = "var", var_value: int | None = None, decimals: int | None = None) -> int:
-    if not isinstance(value, str):
-        raise ValueError(f"value is not str: {value}")
-    try:
-        var_name = var_name.lower()
-        result = 0
-        for item in split_on_plus_minus_tokens(value.lower()):
-            operator = item[0]
-            item = item[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("base 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"wrong value: {value}, error={err}") from err
-
-
-def calc_decimal_value(value: str) -> Decimal:
-    value = value.lower().strip()
-    if value.startswith("random(") and value.endswith(")"):
-        arr = value.lstrip("random(").rstrip(")").split(",")
-        if len(arr) != 2:
-            raise ValueError(f"wrong value, random part: {value}")
-        from_value = Decimal(arr[0])
-        to_value = Decimal(arr[1])
-        if from_value > to_value:
-            raise ValueError(f"wrong value, random part: {value}")
-        return random_decimal(from_value, to_value)
-    return Decimal(value)
-
-
-def calc_function_args(value: str) -> str:
-    while True:
-        if "random(" not in value:
-            return value
-        start_index = value.index("random(")
-        stop_index = value.index(")", start_index)
-        random_range = [int(v.strip()) for v in value[start_index + 7 : stop_index].split(",")]
-        if len(random_range) != 2:
-            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 :]

mm_eth/cli/cli.py

@@ -1,237 +0,0 @@
-from enum import Enum
-from typing import Annotated, Union
-
-import typer
-from mm_std import PrintFormat, print_plain
-
-from mm_eth.cli import cli_helpers
-from mm_eth.cli.cmd import (
-    balance_cmd,
-    balances_cmd,
-    call_contract_cmd,
-    config_example_cmd,
-    deploy_cmd,
-    encode_input_data_cmd,
-    mnemonic_cmd,
-    node_cmd,
-    private_key_cmd,
-    rpc_cmd,
-    send_contract_cmd,
-    solc_cmd,
-    token_cmd,
-    transfer_erc20_cmd,
-    transfer_eth_cmd,
-    vault_cmd,
-)
-
-app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
-
-wallet_app = typer.Typer(no_args_is_help=True, help="Wallet commands: generate mnemonic, private to address")
-app.add_typer(wallet_app, name="wallet")
-app.add_typer(wallet_app, name="w", hidden=True)
-
-
-class ConfigExample(str, Enum):
-    TRANSFER_ETH = "transfer-eth"
-    TRANSFER_ERC20 = "transfer-erc20"
-    BALANCES = "balances"
-    CALL_CONTRACT = "call-contract"
-
-
-@app.command(name="balance", help="Gen account balance")
-def balance_command(
-    wallet_address: Annotated[str, typer.Argument()],
-    token_address: Annotated[Union[str | None], typer.Option("--token", "-t")] = None,  # noqa UP007
-    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL")] = "",  # nosec
-    wei: bool = typer.Option(False, "--wei", "-w", help="Print balances in wei units"),
-    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
-) -> None:
-    balance_cmd.run(rpc_url, wallet_address, token_address, wei, print_format)
-
-
-@app.command(name="token", help="Get token info")
-def token_command(
-    token_address: Annotated[str, typer.Argument()],
-    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL")] = "",
-) -> None:
-    token_cmd.run(rpc_url, token_address)
-
-
-@app.command(name="node", help="Check RPC url")
-def node_command(
-    urls: Annotated[list[str], typer.Argument()],
-    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.TABLE,
-    proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
-) -> None:
-    node_cmd.run(urls, print_format, proxy)
-
-
-@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")] = "",
-    print_path: bool = typer.Option(False, "--print_path"),
-    path_prefix: Annotated[str, typer.Option("--path")] = "m/44'/60'/0'/0",
-    limit: int = typer.Option(10, "--limit", "-l"),
-    save_file: str = typer.Option("", "--save", "-s", help="Save private keys to a file"),
-) -> None:
-    mnemonic_cmd.run(
-        mnemonic,
-        passphrase=passphrase,
-        print_path=print_path,
-        limit=limit,
-        path_prefix=path_prefix,
-        save_file=save_file,
-    )
-
-
-@wallet_app.command(name="private-key", help="Print an address for a private key")
-def private_key_command(private_key: str) -> None:
-    private_key_cmd.run(private_key)
-
-
-@app.command(name="solc", help="Compile a solidity file")
-def solc_command(
-    contract_path: str,
-    tmp_dir: str = "/tmp",  # nosec
-    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
-) -> None:
-    solc_cmd.run(contract_path, tmp_dir, print_format)
-
-
-@app.command(name="vault", help="Save private keys to vault")
-def vault_command(
-    keys_url: Annotated[
-        str,
-        typer.Option(..., "--url", "-u", help="Url to keys, for example https://vault.site.com:8200/v1/kv/keys1"),
-    ],
-    vault_token: Annotated[
-        str,
-        typer.Option(..., "--token", "-t", prompt=True, hide_input=True, prompt_required=False, help="A vault token"),
-    ],
-    keys_file: Annotated[str, typer.Option(..., "--file", "-f", help="Path to a file with private keys")],
-) -> None:
-    vault_cmd.run(keys_url, vault_token, keys_file)
-
-
-@app.command(name="rpc", help="Call a JSON-RPC method")
-def rpc_command(
-    method: Annotated[str, typer.Argument()] = "",
-    params: Annotated[str, typer.Argument()] = "[]",
-    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL", help="RPC node url")] = "",
-    hex2dec: Annotated[bool, typer.Option("--hex2dec", "-d", help="Print result in decimal value")] = False,
-) -> None:
-    rpc_cmd.run(rpc_url, method, params, hex2dec)
-
-
-@app.command(name="transfer-eth", help="Transfer eth / base token from one or many accounts")
-def transfer_eth_command(
-    config_path: str,
-    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(
-        config_path,
-        print_balances=print_balances,
-        print_config=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(
-    config_path: str,
-    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_erc20_cmd.run(
-        config_path,
-        print_balances=print_balances,
-        print_config=print_config,
-        debug=debug,
-        no_receipt=no_receipt,
-        emulate=emulate,
-    )
-
-
-@app.command(name="send-contract", help="Send transactions to a contract")
-def send_contract_command(
-    config_path: str,
-    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:
-    send_contract_cmd.run(
-        config_path,
-        print_balances=print_balances,
-        print_config=print_config,
-        debug=debug,
-        no_receipt=no_receipt,
-        emulate=emulate,
-    )
-
-
-@app.command(name="balances", help="Print base and ERC20 token balances")
-def balances_command(
-    config_path: str,
-    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only and exit"),
-    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(config_path, print_config, wei, nonce)
-
-
-@app.command(name="call-contract", help="Call a method on a contract")
-def call_contract_command(
-    config_path: str,
-    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only and exit"),
-) -> None:
-    call_contract_cmd.run(config_path, print_config)
-
-
-@app.command(name="deploy", help="Deploy a smart contract onchain")
-def deploy_command(
-    config_path: str,
-    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only and exit"),
-) -> None:
-    deploy_cmd.run(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="encode-input-data", help="Encode input data by a function signature")
-def encode_input_data(
-    funtion_signature: str = typer.Argument(help="Function signature, for example: transfer(address, uint256)"),
-    args_str: str = typer.Argument(
-        help="""Function arguments, as an array string. For example: '["0xA659FB44eB5d4bFaC1074Cb426b1b11D58D28308", 123]' """,
-    ),
-) -> None:
-    encode_input_data_cmd.run(funtion_signature, args_str)
-
-
-def version_callback(value: bool) -> None:
-    if value:
-        print_plain(f"mm-eth version: {cli_helpers.get_version()}")
-        raise typer.Exit()
-
-
-@app.callback()
-def main(_version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=True)) -> None:
-    pass
-
-
-if __name__ == "__main_":
-    app()

mm_eth/cli/cli_helpers.py

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

@@ -1,148 +0,0 @@
-import sys
-import time
-from pathlib import Path
-
-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
-
-# from typing import TypeVar
-
-
-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)))
-
-
-def read_config[T](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