mm-eth 0.7.3__py3-none-any.whl → 0.8.0__py3-none-any.whl

mm_eth/__init__.py

@@ -0,0 +1 @@
+"""Python library for interacting with EVM blockchains."""

mm_eth/abi.py

@@ -1,3 +1,5 @@
+"""ABI encoding, decoding, and function signature utilities."""
+
 import string
 from collections.abc import Sequence
 from dataclasses import dataclass
@@ -13,16 +15,21 @@ from web3.auto import w3
 
 @dataclass
 class NameTypeValue:
+    """A named, typed ABI parameter value."""
+
     name: str
     type: str
     value: Any
 
 
 class FunctionInput(BaseModel):
+    """Decoded function input with ABI metadata and parameter values."""
+
     function_abi: ABIFunction
     params: dict[str, Any]
 
     def decode_params_bytes(self) -> dict[str, Any]:
+        """Convert bytes parameters to human-readable hex or text strings."""
         result: dict[str, Any] = {}
         for k, v in self.params.items():
             if isinstance(v, bytes):
@@ -36,10 +43,12 @@ class FunctionInput(BaseModel):
         return result
 
     def function_signature(self) -> str:
+        """Return the function signature string, e.g. 'transfer(to,value)'."""
         inputs = [i["name"] for i in self.function_abi["inputs"]]
         return self.function_abi["name"] + f"({','.join(inputs)})"
 
     def to_list(self, decode_bytes: bool = False) -> list[NameTypeValue]:
+        """Convert parameters to a list of NameTypeValue, optionally decoding bytes."""
         result = []
         for param in self.function_abi["inputs"]:
             name = param["name"]
@@ -55,12 +64,14 @@ class FunctionInput(BaseModel):
 
 
 def decode_function_input(contract_abi: ABI, tx_input: str) -> FunctionInput:
+    """Decode a transaction input hex string using the contract ABI."""
     contract = w3.eth.contract(abi=contract_abi)
     func, params = contract.decode_function_input(HexStr(tx_input))
     return FunctionInput(function_abi=func.abi, params=params)
 
 
 def get_function_abi(contr_abi: ABI, fn_name: str) -> ABIFunction:
+    """Find and return the ABI entry for a function by name."""
     abi = next((x for x in contr_abi if x.get("name", None) == fn_name and x.get("type", None) == "function"), None)
     if not abi:
         raise ValueError("can't find abi for function: " + fn_name)
@@ -68,6 +79,7 @@ def get_function_abi(contr_abi: ABI, fn_name: str) -> ABIFunction:
 
 
 def encode_function_input_by_abi(abi: ABI | ABIFunction, fn_name: str, args: list[Any]) -> HexStr:
+    """Encode function call data using a contract ABI or function ABI."""
     # if abi is contract_abi, get function_abi
     if isinstance(abi, Sequence):
         abi = get_function_abi(abi, fn_name)
@@ -85,6 +97,7 @@ def encode_function_input_by_abi(abi: ABI | ABIFunction, fn_name: str, args: lis
 
 
 def encode_function_input_by_signature(func_signature: str, args: list[Any]) -> HexStr:
+    """Encode function call data from a signature string like 'func1(uint256,address)'."""
     if not func_signature.endswith(")"):
         raise ValueError(f"wrong func_signature={func_signature}. example: func1(uint256,address)")
     func_signature = func_signature.removesuffix(")")
@@ -102,20 +115,22 @@ def encode_function_input_by_signature(func_signature: str, args: list[Any]) ->
 
 
 def encode_function_signature(func_name_with_types: str) -> HexStr:
-    """input example 'transfer(address,uint256)'"""
+    """Encode a 4-byte function selector from a function signature like 'transfer(address,uint256)'."""
     return HexStr(eth_utils.to_hex(Web3.keccak(text=func_name_with_types))[0:10])
 
 
 def decode_data(types: list[str], data: str) -> tuple[Any, ...]:
+    """Decode ABI-encoded hex data into a tuple of values."""
     return eth_abi.decode(types, eth_utils.to_bytes(hexstr=HexStr(data)))
 
 
 def encode_data(types: list[str], args: list[Any]) -> str:
+    """ABI-encodes values into a hex string."""
     return eth_utils.to_hex(eth_abi.encode(types, args))
 
 
 def parse_function_signatures(contract_abi: ABI) -> dict[str, str]:
-    """returns dict, key: function_name_and_types, value: 4bytes signature"""
+    """Return dict, key: function_name_and_types, value: 4bytes signature."""
     result: dict[str, str] = {}
     for item in contract_abi:
         if item.get("type", None) == "function":

mm_eth/account.py

@@ -1,3 +1,5 @@
+"""Ethereum account generation, derivation, and key utilities."""
+
 from dataclasses import dataclass
 
 import eth_utils
@@ -27,35 +29,13 @@ class DerivedAccount:
 
 
 def generate_mnemonic(num_words: int = 24) -> str:
-    """
-    Generates a BIP39 mnemonic phrase in English.
-
-    Args:
-        num_words (int): Number of words in the mnemonic (12, 15, 18, 21, or 24).
-
-    Returns:
-        str: Generated mnemonic phrase.
-    """
+    """Generate a BIP39 mnemonic phrase in English."""
     mnemonic = Mnemonic(Language.ENGLISH)
     return mnemonic.generate(num_words=num_words)
 
 
 def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit: int) -> list[DerivedAccount]:
-    """
-    Derives multiple Ethereum accounts from a given mnemonic phrase.
-
-    Args:
-        mnemonic (str): BIP39 mnemonic phrase.
-        passphrase (str): Optional BIP39 passphrase.
-        derivation_path (str): Path template with '{i}' as index placeholder.
-        limit (int): Number of accounts to derive.
-
-    Raises:
-        ValueError: If derivation_path does not contain '{i}'.
-
-    Returns:
-        list[DerivedAccount]: List of derived Ethereum accounts.
-    """
+    """Derive multiple Ethereum accounts from a mnemonic phrase."""
     if "{i}" not in derivation_path:
         raise ValueError("derivation_path must contain {i}, for example: " + DEFAULT_DERIVATION_PATH)
 
@@ -69,16 +49,7 @@ def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit:
 
 
 def private_to_address(private_key: str, lower: bool = False) -> Result[str]:
-    """
-    Converts a private key to its corresponding Ethereum address.
-
-    Args:
-        private_key (str): Hex-encoded private key.
-        lower (bool): Whether to return address in lowercase.
-
-    Returns:
-        Result[str]: Ok(address) or Err(exception) on failure.
-    """
+    """Convert a private key to its corresponding Ethereum address."""
     try:
         acc: LocalAccount = Account.from_key(private_key)
         address = acc.address.lower() if lower else acc.address
@@ -88,15 +59,7 @@ def private_to_address(private_key: str, lower: bool = False) -> Result[str]:
 
 
 def is_private_key(private_key: str) -> bool:
-    """
-    Checks if a given hex string is a valid Ethereum private key.
-
-    Args:
-        private_key (str): Hex-encoded private key.
-
-    Returns:
-        bool: True if valid, False otherwise.
-    """
+    """Check if a hex string is a valid Ethereum private key."""
     try:
         key_api.PrivateKey(eth_utils.decode_hex(private_key)).public_key.to_address()
         return True  # noqa: TRY300

mm_eth/anvil.py

@@ -1,3 +1,5 @@
+"""Anvil (local Ethereum node) process management."""
+
 from __future__ import annotations
 
 import socket
@@ -11,27 +13,34 @@ from mm_eth import account, rpc
 
 
 class Anvil:
+    """Manages an Anvil local Ethereum node process."""
+
     def __init__(self, *, chain_id: int, port: int, mnemonic: str) -> None:
+        """Initialize Anvil configuration without starting the process."""
         self.chain_id = chain_id
         self.port = port
         self.mnemonic = mnemonic
         self.process: Popen | None = None  # type: ignore[type-arg]
 
     def start_process(self) -> None:
+        """Start the Anvil subprocess."""
         cmd = f"anvil -m '{self.mnemonic}' -p {self.port} --chain-id {self.chain_id}"
         self.process = Popen(cmd, shell=True)  # noqa: S602 # nosec
         time.sleep(3)
 
     def stop(self) -> None:
+        """Kill the Anvil subprocess if running."""
         if self.process:
             self.process.kill()
 
     async def check(self) -> bool:
+        """Verify the Anvil node is running and has the expected chain ID."""
         res = await rpc.eth_chain_id(self.rpc_url)
         return res.is_ok() and res.unwrap() == self.chain_id
 
     @property
     def rpc_url(self) -> str:
+        """Return the local HTTP RPC URL for this Anvil instance."""
         return f"http://localhost:{self.port}"
 
     @classmethod
@@ -42,6 +51,7 @@ class Anvil:
         mnemonic: str = "",
         attempts: int = 3,
     ) -> Result[Anvil]:
+        """Launch an Anvil instance, retrying on failure up to the given number of attempts."""
         if not mnemonic:
             mnemonic = account.generate_mnemonic()
 
@@ -58,6 +68,7 @@ class Anvil:
 
 
 def get_free_local_port() -> int:
+    """Find and return an available local TCP port."""
     sock = socket.socket()
     sock.bind(("", 0))
     port = sock.getsockname()[1]

mm_eth/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI interface for mm-eth."""

mm_eth/cli/calcs.py

@@ -1,11 +1,15 @@
+"""Expression calculators for ETH and token values."""
+
 import mm_web3
 
 from mm_eth.cli.validators import SUFFIX_DECIMALS
 
 
 def calc_eth_expression(expression: str, variables: dict[str, int] | None = None) -> int:
+    """Evaluate an expression with ETH unit suffixes (eth, gwei, ether) to wei."""
     return mm_web3.calc_expression_with_vars(expression, variables, unit_decimals=SUFFIX_DECIMALS)
 
 
 def calc_token_expression(expression: str, token_decimals: int, variables: dict[str, int] | None = None) -> int:
+    """Evaluate an expression with token unit suffix (t) to the smallest token unit."""
     return mm_web3.calc_expression_with_vars(expression, variables, unit_decimals={"t": token_decimals})

mm_eth/cli/cli.py

@@ -1,10 +1,12 @@
+"""Main CLI application and command definitions."""
+
 import asyncio
 import importlib.metadata
 from pathlib import Path
 from typing import Annotated
 
-import mm_print
 import typer
+from mm_print import print_plain
 
 from mm_eth.account import DEFAULT_DERIVATION_PATH
 from mm_eth.cli.cli_utils import PrintFormat
@@ -31,6 +33,7 @@ def mnemonic_command(  # nosec
     limit: int = typer.Option(10, "--limit", "-l"),
     save_file: str = typer.Option("", "--save", "-s", help="Save private keys to a file"),
 ) -> None:
+    """Generate or derive ETH accounts from a mnemonic phrase."""
     mnemonic_cmd.run(
         mnemonic,
         passphrase=passphrase,
@@ -44,6 +47,7 @@ def mnemonic_command(  # nosec
 
 @wallet_app.command(name="private-key", help="Print an address for a private key")
 def private_key_command(private_key: str) -> None:
+    """Print the address for a given private key."""
     private_key_cmd.run(private_key)
 
 
@@ -53,6 +57,7 @@ def node_command(
     proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
     print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.TABLE,
 ) -> None:
+    """Check RPC node URLs and display chain info."""
     asyncio.run(node_cmd.run(urls, proxy, print_format))
 
 
@@ -64,6 +69,7 @@ def balance_command(
     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:
+    """Print ETH and optional ERC-20 token balance for an address."""
     asyncio.run(balance_cmd.run(rpc_url, wallet_address, token_address, wei, print_format))
 
 
@@ -74,6 +80,7 @@ def balances_command(
     nonce: bool = typer.Option(False, "--nonce", "-n", help="Print nonce also"),
     wei: bool = typer.Option(False, "--wei", "-w", help="Show balances in WEI"),
 ) -> None:
+    """Print base and ERC-20 token balances for multiple addresses."""
     asyncio.run(
         balances_cmd.run(BalancesCmdParams(config_path=config_path, print_config=print_config, wei=wei, show_nonce=nonce))
     )
@@ -85,6 +92,7 @@ def solc_command(
     tmp_dir: Path = Path("/tmp"),  # noqa: S108 # nosec
     print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
 ) -> None:
+    """Compile a Solidity file and print the ABI and bytecode."""
     solc_cmd.run(contract_path, tmp_dir, print_format)
 
 
@@ -93,6 +101,7 @@ def deploy_command(
     config_path: Path,
     print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
 ) -> None:
+    """Deploy a smart contract onchain from a config file."""
     asyncio.run(deploy_cmd.run(DeployCmdParams(config_path=config_path, print_config=print_config)))
 
 
@@ -108,6 +117,7 @@ def transfer_command(
     skip_receipt: bool = typer.Option(False, "--skip-receipt", help="Don't wait for a tx receipt"),
     debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
 ) -> None:
+    """Transfer ETH or ERC-20 tokens based on a config file."""
     asyncio.run(
         transfer_cmd.run(
             TransferCmdParams(
@@ -124,14 +134,15 @@ def transfer_command(
 
 
 def version_callback(value: bool) -> None:
+    """Print the version and exit when --version is passed."""
     if value:
-        mm_print.plain(f"mm-eth: {importlib.metadata.version('mm-eth')}")
+        print_plain(f"mm-eth: {importlib.metadata.version('mm-eth')}")
         raise typer.Exit
 
 
 @app.callback()
 def main(_version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=True)) -> None:
-    pass
+    """CLI entry point for mm-eth."""
 
 
 if __name__ == "__main_":

mm_eth/cli/cli_utils.py

@@ -1,8 +1,11 @@
+"""Shared CLI utilities, config base classes, and output helpers."""
+
 import importlib.metadata
-from enum import Enum, unique
+from enum import StrEnum, unique
 from pathlib import Path
+from typing import NoReturn
 
-import mm_print
+import typer
 from pydantic import BaseModel
 from rich.table import Table
 
@@ -10,13 +13,16 @@ from mm_eth import rpc
 
 
 @unique
-class PrintFormat(str, Enum):
+class PrintFormat(StrEnum):
+    """Output format for CLI commands."""
+
     PLAIN = "plain"
     TABLE = "table"
     JSON = "json"
 
 
 def public_rpc_url(url: str | None) -> str:
+    """Resolve a network name or alias to a public RPC URL."""
     if not url or url == "1":
         return "https://ethereum-rpc.publicnode.com"
     if url.startswith(("http://", "https://", "ws://", "wss://")):
@@ -38,20 +44,31 @@ def public_rpc_url(url: str | None) -> str:
 
 
 class BaseConfigParams(BaseModel):
+    """Base parameters shared by CLI commands that read a config file."""
+
     config_path: Path
     print_config: bool
 
 
 async def check_nodes_for_chain_id(nodes: list[str], chain_id: int) -> None:
+    """Validate that all nodes return the expected chain ID, exiting on mismatch."""
     for node in nodes:
         res = (await rpc.eth_chain_id(node)).unwrap("can't get chain_id")
         if res != chain_id:
-            mm_print.exit_with_error(f"node {node} has a wrong chain_id: {res}")
+            fatal(f"node {node} has a wrong chain_id: {res}")
 
 
 def add_table_raw(table: Table, *row: object) -> None:
+    """Add a row to a Rich table, converting all values to strings."""
     table.add_row(*[str(cell) for cell in row])
 
 
 def get_version() -> str:
+    """Return the installed mm-eth package version."""
     return importlib.metadata.version("mm-eth")
+
+
+def fatal(message: str) -> NoReturn:
+    """Print an error message and exit with code 1."""
+    typer.echo(message)
+    raise typer.Exit(1)

mm_eth/cli/cmd/__init__.py

@@ -0,0 +1 @@
+"""CLI command implementations."""

mm_eth/cli/cmd/balance_cmd.py

@@ -1,5 +1,7 @@
+"""CLI command: print account balance."""
+
 import eth_utils
-import mm_print
+from mm_print import print_json, print_plain
 
 from mm_eth import converters, rpc
 from mm_eth.cli import cli_utils
@@ -7,13 +9,14 @@ from mm_eth.cli.cli import PrintFormat
 
 
 async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool, print_format: PrintFormat) -> None:
+    """Fetch and print ETH and optional ERC-20 token balance for an address."""
     result: dict[str, object] = {}
     rpc_url = cli_utils.public_rpc_url(rpc_url)
 
     # nonce
     result["nonce"] = (await rpc.eth_get_transaction_count(rpc_url, wallet_address)).value_or_error()
     if print_format == PrintFormat.PLAIN:
-        mm_print.plain(f"nonce: {result['nonce']}")
+        print_plain(f"nonce: {result['nonce']}")
 
     # eth balance
     result["eth_balance"] = (
@@ -22,18 +25,18 @@ async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei:
         .value_or_error()
     )
     if print_format == PrintFormat.PLAIN:
-        mm_print.plain(f"eth_balance: {result['eth_balance']}")
+        print_plain(f"eth_balance: {result['eth_balance']}")
 
     if token_address:
         # token decimal
         result["token_decimal"] = (await rpc.erc20_decimals(rpc_url, token_address)).value_or_error()
         if print_format == PrintFormat.PLAIN:
-            mm_print.plain(f"token_decimal: {result['token_decimal']}")
+            print_plain(f"token_decimal: {result['token_decimal']}")
 
         # token symbol
         result["token_symbol"] = (await rpc.erc20_symbol(rpc_url, token_address)).value_or_error()
         if print_format == PrintFormat.PLAIN:
-            mm_print.plain(f"token_symbol: {result['token_symbol']}")
+            print_plain(f"token_symbol: {result['token_symbol']}")
 
         # token balance
         result["token_balance"] = (await rpc.erc20_balance(rpc_url, token_address, wallet_address)).value_or_error()
@@ -41,7 +44,7 @@ async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei:
             result["token_balance"] = converters.from_wei(result["token_balance"], "t", decimals=result["token_decimal"])
 
         if print_format == PrintFormat.PLAIN:
-            mm_print.plain(f"token_balance: {result['token_balance']}")
+            print_plain(f"token_balance: {result['token_balance']}")
 
     if print_format == PrintFormat.JSON:
-        mm_print.json(data=result)
+        print_json(data=result)

mm_eth/cli/cmd/balances_cmd.py

@@ -1,18 +1,21 @@
+"""CLI command: print balances for multiple addresses and tokens."""
+
 from dataclasses import dataclass
 from typing import Annotated
 
-import mm_print
 from mm_web3 import Web3CliConfig
 from pydantic import BeforeValidator
 from rich.live import Live
 from rich.table import Table
 
 from mm_eth import converters, retry
-from mm_eth.cli.cli_utils import BaseConfigParams
+from mm_eth.cli.cli_utils import BaseConfigParams, fatal
 from mm_eth.cli.validators import Validators
 
 
 class Config(Web3CliConfig):
+    """Configuration for the balances command."""
+
     addresses: Annotated[list[str], BeforeValidator(Validators.eth_addresses(unique=True))]
     tokens: Annotated[list[str], BeforeValidator(Validators.eth_addresses(unique=True))]
     nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
@@ -21,17 +24,22 @@ class Config(Web3CliConfig):
 
 @dataclass
 class Token:
+    """Resolved ERC-20 token metadata."""
+
     address: str
     decimals: int
     symbol: str
 
 
 class BalancesCmdParams(BaseConfigParams):
+    """Parameters for the balances command."""
+
     wei: bool
     show_nonce: bool
 
 
 async def run(params: BalancesCmdParams) -> None:
+    """Read config, fetch balances for all addresses/tokens, and display a table."""
     config = Config.read_toml_config_or_exit(params.config_path)
     if params.print_config:
         config.print_and_exit()
@@ -101,16 +109,17 @@ async def run(params: BalancesCmdParams) -> None:
 
 
 async def _get_tokens_info(config: Config) -> list[Token]:
+    """Fetch decimals and symbol for each configured token address."""
     result: list[Token] = []
     for address in config.tokens:
         decimals_res = await retry.erc20_decimals(5, config.nodes, None, token=address)
         if decimals_res.is_err():
-            mm_print.exit_with_error(f"can't get token {address} decimals: {decimals_res.unwrap_err()}")
+            fatal(f"can't get token {address} decimals: {decimals_res.unwrap_err()}")
         decimal = decimals_res.unwrap()
 
         symbols_res = await retry.erc20_symbol(5, config.nodes, None, token=address)
         if symbols_res.is_err():
-            mm_print.exit_with_error(f"can't get token {address} symbol: {symbols_res.unwrap_err()}")
+            fatal(f"can't get token {address} symbol: {symbols_res.unwrap_err()}")
         symbol = symbols_res.unwrap()
 
         result.append(Token(address=address, decimals=decimal, symbol=symbol))

mm_eth/cli/cmd/deploy_cmd.py

@@ -1,7 +1,9 @@
+"""CLI command: deploy a smart contract."""
+
 from typing import cast
 
-import mm_print
 import tomlkit
+from mm_print import print_json
 from mm_web3 import Web3CliConfig
 from pydantic import StrictStr
 
@@ -10,6 +12,8 @@ from mm_eth.cli.cli_utils import BaseConfigParams
 
 
 class Config(Web3CliConfig):
+    """Configuration for the deploy command."""
+
     private_key: StrictStr
     nonce: int | None = None
     gas: int
@@ -24,10 +28,13 @@ class Config(Web3CliConfig):
 
 
 class DeployCmdParams(BaseConfigParams):
+    """Parameters for the deploy command."""
+
     broadcast: bool = False
 
 
 async def run(cli_params: DeployCmdParams) -> None:
+    """Read deploy config, build contract data, and print the deployment payload."""
     config = Config.read_toml_config_or_exit(cli_params.config_path)
     if cli_params.print_config:
         config.print_and_exit({"private_key"})
@@ -44,4 +51,4 @@ async def run(cli_params: DeployCmdParams) -> None:
         )
 
     res = deploy.get_deploy_contract_data(config.contract_bin, constructor_types, constructor_values)
-    mm_print.json(res)
+    print_json(res)

mm_eth/cli/cmd/node_cmd.py

@@ -1,8 +1,10 @@
+"""CLI command: check RPC node status."""
+
 from decimal import Decimal
 
 import eth_utils
-import mm_print
 import pydash
+from mm_print import print_json
 from pydantic import BaseModel
 from rich.live import Live
 from rich.table import Table
@@ -12,6 +14,8 @@ from mm_eth.cli.cli import PrintFormat
 
 
 class NodeInfo(BaseModel):
+    """RPC node status information."""
+
     url: str
     chain_id: int | str
     chain_name: str
@@ -19,11 +23,15 @@ class NodeInfo(BaseModel):
     base_fee: str | int | Decimal
 
     def table_row(self) -> list[object]:
+        """Return the node info fields as a list for table rendering."""
         return [self.url, self.chain_id, self.chain_name, self.block_number, self.base_fee]
 
 
 class LiveTable:
+    """Wrapper around Rich's Live table for incremental row display."""
+
     def __init__(self, table: Table, ignore: bool = False) -> None:
+        """Initialize the live table, optionally disabling live output."""
         self.ignore = ignore
         if ignore:
             return
@@ -32,18 +40,21 @@ class LiveTable:
         self.live.start()
 
     def add_row(self, *args: object) -> None:
+        """Add a row to the table and refresh the live display."""
         if self.ignore:
             return
         self.table.add_row(*(str(a) for a in args))
         self.live.refresh()
 
     def stop(self) -> None:
+        """Stop the live display."""
         if self.ignore:
             return
         self.live.stop()
 
 
 async def run(urls: list[str], proxy: str | None, print_format: PrintFormat) -> None:
+    """Query each RPC URL and display chain ID, block number, and base fee."""
     urls = pydash.uniq(urls)
     result = []
     live_table = LiveTable(
@@ -58,7 +69,7 @@ async def run(urls: list[str], proxy: str | None, print_format: PrintFormat) ->
     live_table.stop()
 
     if print_format == PrintFormat.JSON:
-        mm_print.json(data=result)
+        print_json(data=result)
     # print_json(data=result)
     # table = Table(*["url", "chain_id", "chain_name", "block_number", "base_fee"], title="nodes")
 
@@ -68,6 +79,7 @@ async def run(urls: list[str], proxy: str | None, print_format: PrintFormat) ->
 
 
 async def _get_node_info(url: str, proxy: str | None) -> NodeInfo:
+    """Fetch chain ID, block number, and base fee from a single RPC node."""
     chain_id_res = await rpc.eth_chain_id(url, proxy=proxy)
     chain_id = chain_id_res.value_or_error()
     chain_name = ""