mm-eth 0.5.17__py3-none-any.whl → 0.6.0__py3-none-any.whl

mm_eth/solc.py

@@ -1,9 +1,10 @@
 import random
+import re
 import shutil
 from dataclasses import dataclass
 from pathlib import Path
 
-from mm_std import Err, Ok, Result, run_command
+from mm_std import Result, run_command
 
 
 @dataclass
@@ -12,22 +13,34 @@ class SolcResult:
     abi: str
 
 
-def solc(contract_name: str, contract_path: str, tmp_dir: str) -> Result[SolcResult]:
-    if tmp_dir.startswith("~"):
-        tmp_dir = Path(tmp_dir).expanduser().as_posix()
-    if contract_path.startswith("~"):
-        contract_path = Path(contract_path).expanduser().as_posix()
-    work_dir = f"{tmp_dir}/solc_{contract_name}_{random.randint(0, 100_000_000)}"
-    abi_path = f"{work_dir}/{contract_name}.abi"
-    bin_path = f"{work_dir}/{contract_name}.bin"
+def solc(contract_name: str, contract_path: Path, tmp_dir: Path) -> Result[SolcResult]:
+    # Sanitize contract name to avoid unsafe characters in directory name
+    safe_name = re.sub(r"[^a-zA-Z0-9_\-]", "_", contract_name)
+
+    # Expand ~ in paths if present
+    contract_path = contract_path.expanduser().resolve()
+    tmp_dir = tmp_dir.expanduser().resolve()
+
+    work_dir = tmp_dir / f"solc_{safe_name}_{random.randint(0, 100_000_000)}"
+    abi_path = work_dir / f"{contract_name}.abi"
+    bin_path = work_dir / f"{contract_name}.bin"
+
+    work_dir_created = False
     try:
-        Path(work_dir).mkdir(parents=True)
-        cmd = f"solc -o '{work_dir}' --abi --bin --optimize {contract_path}"
-        run_command(cmd)
-        abi = Path(abi_path).read_text()
-        bin_ = Path(bin_path).read_text()
-        return Ok(SolcResult(bin=bin_, abi=abi))
+        work_dir.mkdir(parents=True, exist_ok=False)
+        work_dir_created = True
+
+        cmd = f"solc -o '{work_dir}' --abi --bin --optimize '{contract_path}'"
+        result = run_command(cmd)
+        if result.code != 0:
+            return Result.err(f"solc error: {result.stderr}")
+
+        abi = abi_path.read_text()
+        bin_ = bin_path.read_text()
+
+        return Result.ok(SolcResult(bin=bin_, abi=abi))
     except Exception as e:
-        return Err(f"exception: {e}")
+        return Result.err(e)
     finally:
-        shutil.rmtree(work_dir, ignore_errors=True)
+        if work_dir_created:
+            shutil.rmtree(work_dir, ignore_errors=True)

mm_eth/tx.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 
 from typing import Any
 
+import eth_utils
 import rlp
 from eth_account import Account
+from eth_typing import HexStr
 from eth_utils import keccak, to_hex
 from pydantic import BaseModel
 from rlp.sedes import Binary, big_endian_int, binary
 from web3 import Web3
-from web3.auto import w3
-
-from mm_eth.utils import hex_to_bytes
 
 
 class SignedTx(BaseModel):
@@ -45,9 +44,9 @@ class RPLTransaction(rlp.Serializable):  # type: ignore[misc]
         to: str | None = None,
     ) -> RPLTransaction:
         if to:
-            to = hex_to_bytes(to)  # type: ignore[assignment]
+            to = eth_utils.to_bytes(hexstr=HexStr(to))  # type:ignore[assignment]
         if data:
-            data = hex_to_bytes(data)  # type: ignore[assignment]
+            data = eth_utils.to_bytes(hexstr=HexStr(data))  # type:ignore[assignment]
         if not value:
             value = 0
         return RPLTransaction(nonce, gas_price, gas, to, value, data, v, int(r, 16), int(s, 16))
@@ -103,7 +102,7 @@ def sign_legacy_tx(
     if data:
         tx["data"] = data
 
-    signed = w3.eth.account.sign_transaction(tx, private_key)
+    signed = Account.sign_transaction(tx, private_key)
     return SignedTx(tx_hash=to_hex(signed.hash), raw_tx=to_hex(signed.raw_transaction))
 
 
@@ -139,9 +138,9 @@ def sign_tx(
 
 
 def decode_raw_tx(raw_tx: str) -> DecodedRawTx:
-    tx: Any = rlp.decode(hex_to_bytes(raw_tx), RPLTransaction)
-    tx_hash = Web3.to_hex(keccak(hex_to_bytes(raw_tx)))
-    from_ = w3.eth.account.recover_transaction(raw_tx)
+    tx: Any = rlp.decode(eth_utils.to_bytes(hexstr=HexStr(raw_tx)), RPLTransaction)
+    tx_hash = Web3.to_hex(keccak(eth_utils.to_bytes(hexstr=HexStr(raw_tx))))
+    from_ = Account.recover_transaction(raw_tx)
     to = Web3.to_checksum_address(tx.to) if tx.to else None
     data = Web3.to_hex(tx.data)
     r = hex(tx.r)

mm_eth/utils.py

@@ -1,216 +1,3 @@
-import re
-from decimal import Decimal, localcontext
-from typing import Any, cast
-
-import aiohttp
-import eth_utils
-import pydash
-from aiohttp_socks import ProxyConnector
-from eth_typing import HexStr
-from hexbytes import HexBytes
-from mm_std import Err, Ok, Result, number_with_separator
-from pydantic import BaseModel
-from web3 import AsyncWeb3, Web3
-from web3.types import Wei
-
-
-def parse_addresses(data: str) -> list[str]:
-    result = []
-    for word in data.lower().split():
-        if len(word) == 42 and re.match("0x[a-f0-9]{40}", word):
-            result.append(word)  # noqa: PERF401
-    return pydash.uniq(result)
-
-
-def to_token_wei(value: str | int, decimals: int) -> int:
-    if isinstance(value, int):
-        return value
-    if isinstance(value, str):
-        value = value.lower().replace(" ", "").strip()
-        if value.endswith("t"):
-            value = value.replace("t", "")
-            return int(Decimal(value) * 10**decimals)
-        if value.isdigit():
-            return int(value)
-
-    raise ValueError("wrong value" + value)
-
-
-def to_wei(value: str | int | Decimal, decimals: int | None = None) -> Wei:
-    if isinstance(value, int):
-        return Wei(value)
-    if isinstance(value, Decimal):
-        if value != value.to_integral_value():
-            raise ValueError(f"value must be integral number: {value}")
-        return Wei(int(value))
-    if isinstance(value, str):
-        value = value.lower().replace(" ", "").strip()
-        if value.endswith("navax"):  # https://snowtrace.io/unitconverter
-            value = value.replace("navax", "")
-            return Wei(int(Decimal(value) * 10**9))
-        if value.endswith("gwei"):
-            value = value.replace("gwei", "")
-            return Wei(int(Decimal(value) * 1000000000))
-        if value.endswith("ether"):
-            value = value.replace("ether", "")
-            return Wei(int(Decimal(value) * 1000000000000000000))
-        if value.endswith("eth"):
-            value = value.replace("eth", "")
-            return Wei(int(Decimal(value) * 1000000000000000000))
-        if value.endswith("t"):
-            if decimals is None:
-                raise ValueError("t without decimals")
-            value = value.removesuffix("t")
-            return Wei(int(Decimal(value) * 10**decimals))
-        if value.isdigit():
-            return Wei(int(value))
-        raise ValueError("wrong value " + value)
-
-    raise ValueError(f"value has a wrong type: {type(value)}")
-
-
-def from_wei(
-    value: int,
-    unit: str,
-    round_ndigits: int | None = None,
-    decimals: int | None = None,
-) -> Decimal:
-    if value == 0:
-        return Decimal(0)
-
-    is_negative = value < 0
-    if unit.lower() == "eth":
-        unit = "ether"
-
-    if unit.lower() == "t":
-        if decimals is None:
-            raise ValueError("t without decimals")
-        with localcontext() as ctx:
-            ctx.prec = 999
-            res = Decimal(value=abs(value), context=ctx) / Decimal(10**decimals)
-    else:
-        res = cast(Decimal, eth_utils.from_wei(abs(value), unit))
-    if round_ndigits is not None:
-        res = round(res, ndigits=round_ndigits)
-    return -1 * res if is_negative else res
-
-
-def from_wei_str(
-    value: int,
-    unit: str,
-    round_ndigits: int | None = None,
-    print_unit_name: bool = True,
-    decimals: int | None = None,
-) -> str:
-    res = format(from_wei(value, unit, round_ndigits, decimals=decimals), "f")
-    if unit == "ether":
-        unit = "eth"
-    if print_unit_name:
-        res += unit
-    return res
-
-
-def from_token_wei_str(value: int, decimals: int, symbol: str = "", round_ndigits: int | None = None) -> str:
-    res = value / 10**decimals
-    if round_ndigits is not None:
-        res = round(res, ndigits=round_ndigits)
-    if symbol:
-        res = f"{res} {symbol}"
-    return str(res)
-
-
-def to_wei_token(value: str | int | Decimal, symbol: str, decimals: int) -> int:
-    if isinstance(value, int):
-        return value
-    if isinstance(value, Decimal):
-        if value != value.to_integral_value():
-            raise ValueError(f"value must be integral number: {value}")
-        return int(value)
-    if isinstance(value, str):
-        value = value.lower().replace(" ", "").strip()
-        if value.isdigit():
-            return int(value)
-        try:
-            return int(Decimal(value.replace(symbol.lower(), "").strip()) * (10**decimals))
-        except Exception as e:
-            raise ValueError from e
-    else:
-        raise TypeError(f"value has a wrong type: {type(value)}")
-
-
-def to_checksum_address(address: str) -> str:
-    return Web3.to_checksum_address(address)
-
-
-def hex_to_bytes(data: str) -> bytes:
-    return eth_utils.to_bytes(hexstr=HexStr(data))
-
-
-def get_chain_name(chain_id: int | str) -> str:
-    chain_id = str(chain_id)
-    if chain_id == "1":
-        return "mainnet"
-    if chain_id == "3":
-        return "ropsten"
-    if chain_id == "5":
-        return "goerli"
-    return chain_id
-
-
-def to_human_readable_tx(tx: dict[str, Any] | BaseModel) -> dict[str, object]:
-    if isinstance(tx, BaseModel):
-        tx = tx.model_dump()
-    tx["human_readable"] = {}
-    tx["human_readable"]["gas_price"] = str(tx["gas_price"] / 10**9) + " gwei"
-    tx["human_readable"]["value"] = str(tx["value"] / 10**18) + " ether"
-    tx["human_readable"]["gas"] = number_with_separator(tx["gas"])
-    if tx.get("chain_id") is not None:
-        tx["human_readable"]["chain_id"] = get_chain_name(tx["chain_id"])
-
-    return tx
-
-
-def truncate_hex_str(hex_str: str, digits: int = 4, replace_str: str = "...") -> str:
-    if not hex_str.startswith("0x") and not hex_str.startswith("0X"):
-        raise ValueError("truncate_hex_str: hex_str must start with 0x")
-    if digits <= 0:
-        raise ValueError("truncate_hex_str: digits must be more than zero")
-    hex_str = hex_str.removeprefix("0x").removeprefix("0X")
-    if digits * 2 >= len(hex_str):
-        raise ValueError("truncate_hex_str: digits is too large")
-    return "0x" + hex_str[:digits] + replace_str + hex_str[-1 * digits :]
-
-
-def log_topic_to_address(topic: HexBytes | str) -> str:
-    result = topic.hex()[-40:] if isinstance(topic, HexBytes) else topic[-40:]
-    if not result.startswith("0x"):
-        result = f"0x{result}"
-    return result
-
-
-def get_w3(rpc_url: str, timeout: float | None = None, proxy: str | None = None) -> Web3:
-    request_kwargs: dict[str, object] = {"timeout": timeout}
-    if proxy:
-        request_kwargs["proxies"] = {"http": proxy, "https": proxy}
-    return Web3(Web3.HTTPProvider(rpc_url, request_kwargs=request_kwargs))
-
-
-async def get_async_w3(rpc_url: str, timeout: float | None = None, proxy: str | None = None) -> AsyncWeb3:
-    # TODO: Don't use async w3. AsyncHTTPProvider uses threads
-    #  check its constructor: self._request_session_manager = HTTPSessionManager()
-    request_kwargs: dict[str, object] = {"timeout": timeout}
-    if proxy and proxy.startswith("http"):
-        request_kwargs["proxy"] = proxy
-    provider = AsyncWeb3.AsyncHTTPProvider(rpc_url, request_kwargs=request_kwargs, exception_retry_configuration=None)
-    w3 = AsyncWeb3(provider)
-
-    if proxy and proxy.startswith("socks"):
-        session = aiohttp.ClientSession(connector=ProxyConnector.from_url(proxy))
-        await provider.cache_async_session(session)
-
-    return w3
-
-
 def name_network(chain_id: int) -> str:
     match chain_id:
         case 1:
@@ -235,14 +22,3 @@ def name_network(chain_id: int) -> str:
             return "Arbitrum Goerli"
         case _:
             return ""
-
-
-def hex_str_to_int(value: str) -> Result[int]:
-    try:
-        return Ok(int(value, 16))
-    except Exception:
-        return Err(f"can't convert to int: {value}")
-
-
-def to_hex(data: bytes | int | bool) -> str:
-    return Web3.to_hex(data)

{mm_eth-0.5.17.dist-info → mm_eth-0.6.0.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-eth
-Version: 0.5.17
+Version: 0.6.0
 Requires-Python: >=3.12
 Requires-Dist: aiohttp-socks~=0.10.1
-Requires-Dist: mm-crypto-utils>=0.2.15
+Requires-Dist: mm-crypto-utils>=0.3.5
+Requires-Dist: mm-std~=0.4.10
 Requires-Dist: typer>=0.15.2
 Requires-Dist: web3~=7.10.0
 Requires-Dist: websocket-client~=1.8.0

mm_eth-0.6.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+mm_eth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/abi.py,sha256=gsIsaq5V8QGdYY424c_t_uVRfg0of7Gk9h0LcW3tkjU,4806
+mm_eth/account.py,sha256=syA89ihOBTA2FiDK3o55oLBVEgPN1rQT_3bUQN05vuk,3044
+mm_eth/anvil.py,sha256=NY1TxYnamfm_47HqCbgUCRdQxPgmAcJ-9YkK3NZ0310,1631
+mm_eth/converters.py,sha256=smL3Bsky1pYEre2kPhsb4arXoQC_u80P5ilU9NRvr44,2043
+mm_eth/deploy.py,sha256=SB3ruY808_5UnG8kHR34uVP66P3zOWZu0ImKD7UUv2s,691
+mm_eth/erc20.py,sha256=Pxs_w95flqEUF4pJMoaHTfvud8x5Fb2UwU7iwMjdGCw,1143
+mm_eth/retry.py,sha256=93MzazJnDZraLavtkBSPoUT-ZZWsLYq4HMf42OlLlBw,4799
+mm_eth/rpc.py,sha256=3LE7ZwefYqwfb1RHcAhdNK99--0r1SW5Rfr9Wg9h50Q,9816
+mm_eth/solc.py,sha256=2FGCJpbkCwIs8hGc8APpvC62gyAXGLeyQMrn4f9Bnow,1348
+mm_eth/tx.py,sha256=zf5fieuKB-CTOiNNjz3siXU7yga7tlh0vkZTDAHvhnQ,4102
+mm_eth/utils.py,sha256=TLyapZZ1lp_kW3vdkHmgR8gUtIQ1aEy_0GScxB6v5IQ,659
+mm_eth/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/calcs.py,sha256=N063Qw85iBNFbDtIjOSYJKHL0vU6wyfRfYAlI9TKeK0,496
+mm_eth/cli/cli.py,sha256=Qac0HizKAyF1wocVvNK2578ntB2JT9kLHr1U5jfQj6E,5580
+mm_eth/cli/cli_utils.py,sha256=jYDuSo-osvKPkd_OJFCHZDfGlFy3LKs-MVKHEnkCPdM,1416
+mm_eth/cli/rpc_helpers.py,sha256=5fxiwFb16V0udY2MOb3bTpUrkf3Lhn-mMXFrdbmAKo4,1669
+mm_eth/cli/validators.py,sha256=74AxIzryQ-D3f5xJYrOnh4AMFugTpsYhUJ_pzhHd2ek,1675
+mm_eth/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/cmd/balance_cmd.py,sha256=hujMv4Fvt4ZMZ3iPOZKdI2u2iN-ClYBmfMn_2Y4lRew,1946
+mm_eth/cli/cmd/balances_cmd.py,sha256=VGCqcPCKPFF2O3WNlryg0nFnCkkKRAaubvpbtH0XTV0,4230
+mm_eth/cli/cmd/deploy_cmd.py,sha256=IItdoOgYt1Q6SpSTxlOecxWikTn3b0_w1-MZkYIBKKI,1266
+mm_eth/cli/cmd/node_cmd.py,sha256=JJSiKGG5OL9p7FuHhNeerjfes6Eo_StgLgpZEy3EUU0,2559
+mm_eth/cli/cmd/solc_cmd.py,sha256=HDLThGAxk8MlJh_OBTsivoXYCKDlGnljRFp-BbYDlU0,714
+mm_eth/cli/cmd/transfer_cmd.py,sha256=kKNoU_kNl2blz9ydbvhlEY1Kck0fCMv4RKwU84HyOSw,16933
+mm_eth/cli/cmd/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/cmd/wallet/mnemonic_cmd.py,sha256=xE-5Ux9BdYsTZYBy0dMn9jupGhW4ced-AgYscy_wU_4,1007
+mm_eth/cli/cmd/wallet/private_key_cmd.py,sha256=wuW_LvmIZiT9T4R8ir0wH1VQ_CEPjmrLgS-vzf0yv70,272
+mm_eth-0.6.0.dist-info/METADATA,sha256=cLC3hqliuUgipT2KS3MSt4JYA-fEZX43oNaY-f2iRuc,275
+mm_eth-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_eth-0.6.0.dist-info/entry_points.txt,sha256=aGhpsozl8NIrkuUcX5fSgURCcDhr3ShUdeTSIrJq4oc,46
+mm_eth-0.6.0.dist-info/RECORD,,

mm_eth/async_rpc.py

@@ -1,94 +0,0 @@
-import json
-from collections.abc import Sequence
-from typing import Any
-
-import websockets
-from mm_crypto_utils import Nodes, Proxies, random_node, random_proxy
-from mm_std import Err, Ok, Result, hra
-
-from mm_eth.utils import hex_str_to_int
-
-
-async def rpc_call(
-    *,
-    nodes: Nodes,
-    method: str,
-    params: Sequence[object],
-    id_: int = 1,
-    timeout: float = 10,
-    proxies: Proxies = None,
-    attempts: int = 1,
-) -> Result[Any]:
-    data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
-    res: Result[Any] = Err("not started yet")
-    for _ in range(attempts):
-        node = random_node(nodes)
-        res = (
-            await _http_call(node, data, timeout, random_proxy(proxies))
-            if node.startswith("http")
-            else await _ws_call(node, data, timeout)
-        )
-        if isinstance(res, Ok):
-            return res
-    return res
-
-
-async def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
-    res = await hra(node, method="POST", proxy=proxy, timeout=timeout, params=data, json_params=True)
-    if res.is_error():
-        return res.to_err_result()
-    try:
-        err = res.json.get("error", {}).get("message", "")
-        if err:
-            return res.to_err_result(f"service_error: {err}")
-        if "result" in res.json:
-            return res.to_ok_result(res.json["result"])
-        return res.to_err_result("unknown_response")
-    except Exception as err:
-        return res.to_err_result(f"exception: {err}")
-
-
-async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result[Any]:
-    try:
-        async with websockets.connect(node, timeout=timeout) as ws:
-            await ws.send(json.dumps(data))
-            response = json.loads(await ws.recv())
-
-        err = response.get("error", {}).get("message", "")
-        if err:
-            return Err(f"service_error: {err}")
-        if "result" in response:
-            return Ok(response["result"], response)
-        return Err(f"unknown_response: {response}")
-    except TimeoutError:
-        return Err("timeout")
-    except Exception as err:
-        return Err(f"exception: {err}")
-
-
-async def eth_block_number(rpc_urls: Nodes, timeout: int = 10, proxies: Proxies = None, attempts: int = 1) -> Result[int]:
-    return (
-        await rpc_call(
-            nodes=rpc_urls,
-            method="eth_blockNumber",
-            params=[],
-            timeout=timeout,
-            proxies=proxies,
-            attempts=attempts,
-        )
-    ).and_then(hex_str_to_int)
-
-
-async def eth_get_balance(
-    rpc_urls: Nodes, address: str, timeout: int = 10, proxies: Proxies = None, attempts: int = 1
-) -> Result[int]:
-    return (
-        await rpc_call(
-            nodes=rpc_urls,
-            method="eth_getBalance",
-            params=[address, "latest"],
-            timeout=timeout,
-            proxies=proxies,
-            attempts=attempts,
-        )
-    ).and_then(hex_str_to_int)

mm_eth/cli/cmd/call_contract_cmd.py

@@ -1,44 +0,0 @@
-import json
-from logging import fatal
-
-from mm_std import BaseConfig, Err, print_plain
-from pydantic import StrictStr
-
-from mm_eth import abi, rpc
-from mm_eth.cli.cli_utils import BaseConfigParams
-
-
-class Config(BaseConfig):
-    contract_address: StrictStr
-    function_signature: str
-    function_args: StrictStr = "[]"
-    outputs_types: str | None = None
-    node: str
-
-
-class CallContractCmdParams(BaseConfigParams):
-    pass
-
-
-def run(cli_params: CallContractCmdParams) -> None:
-    config = Config.read_toml_config_or_exit(cli_params.config_path)
-    if cli_params.print_config:
-        config.print_and_exit()
-
-    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)
-        result = decode_res[0] if len(decode_res) == 1 else 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/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/example_cmd.py

@@ -1,9 +0,0 @@
-from pathlib import Path
-
-from mm_std import pretty_print_toml
-
-
-def run(command: str) -> None:
-    command = command.replace("-", "_")
-    example_file = Path(Path(__file__).parent.absolute(), "../examples", f"{command}.toml")
-    pretty_print_toml(example_file.read_text())

mm_eth/cli/cmd/rpc_cmd.py

@@ -1,78 +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]:
-    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/token_cmd.py

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

mm_eth/cli/cmd/tx_cmd.py

@@ -1,16 +0,0 @@
-from eth_typing import HexStr
-from rich.pretty import pprint
-from web3 import Web3
-
-from mm_eth.cli.cli_utils import public_rpc_url
-
-
-def run(rpc_url: str, tx_hash: str, get_receipt: bool) -> None:
-    rpc_url = public_rpc_url(rpc_url)
-    w3 = Web3(Web3.HTTPProvider(rpc_url))
-    transaction = w3.eth.get_transaction(HexStr(tx_hash))
-    pprint(dict(transaction), expand_all=True)
-
-    if get_receipt:
-        receipt = w3.eth.get_transaction_receipt(HexStr(tx_hash))
-        pprint(dict(receipt), expand_all=True)