mm-eth 0.2.5__tar.gz → 0.3.1__tar.gz

{mm_eth-0.2.5 → mm_eth-0.3.1}/PKG-INFO

@@ -1,9 +1,8 @@
 Metadata-Version: 2.4
 Name: mm-eth
-Version: 0.2.5
+Version: 0.3.1
 Requires-Python: >=3.12
-Requires-Dist: loguru~=0.7.3
-Requires-Dist: mm-std~=0.1.12
+Requires-Dist: mm-crypto-utils>=0.1.4
 Requires-Dist: typer>=0.15.1
 Requires-Dist: web3~=7.7.0
 Requires-Dist: websocket-client~=1.8.0

mm_eth-0.3.1/dict.dic

@@ -0,0 +1,7 @@
+gwei
+ndigits
+opbnb
+sepolia
+nosec
+goerli
+arbitrum

{mm_eth-0.2.5 → mm_eth-0.3.1}/pyproject.toml

@@ -1,15 +1,13 @@
 [project]
 name = "mm-eth"
-version = "0.2.5"
+version = "0.3.1"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
-    "mm-std~=0.1.12",
+    "mm-crypto-utils>=0.1.4",
     "websocket-client~=1.8.0",
     "web3~=7.7.0",
-    "loguru~=0.7.3",
     "typer>=0.15.1",
-
 ]
 [project.scripts]
 mm-eth = "mm_eth.cli.cli:app"
@@ -22,7 +20,7 @@ build-backend = "hatchling.build"
 dev-dependencies = [
     "pytest~=8.3.4",
     "pytest-xdist~=3.6.1",
-    "ruff~=0.9.2",
+    "ruff~=0.9.4",
     "pip-audit~=2.7.3",
     "bandit~=1.8.2",
     "mypy~=1.14.1",

{mm_eth-0.2.5 → mm_eth-0.3.1}/src/mm_eth/account.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 import eth_utils
 from eth_account import Account
 from eth_account.hdaccount import Mnemonic
+from eth_account.signers.local import LocalAccount
 from eth_account.types import Language
 from eth_keys import KeyAPI
 from eth_typing import ChecksumAddress
@@ -44,6 +45,12 @@ def generate_accounts(  # nosec
     return result
 
 
+def address_from_private(private_key: str) -> str:
+    """returns address in lower case"""
+    acc: LocalAccount = Account.from_key(private_key)
+    return acc.address.lower()
+
+
 def private_to_address(private_key: str) -> str | None:
     """returns address in lower case"""
     try:
@@ -52,19 +59,13 @@ def private_to_address(private_key: str) -> str | None:
         return None
 
 
-def create_private_keys_dict(private_keys: list[str]) -> dict[str, str]:  # address in lower
-    result = {}
-    for private_key in private_keys:
-        address = private_to_address(private_key)
-        if address is None:
-            raise ValueError("wrong private key")
-        result[address.lower()] = private_key
-    return result
-
-
 def is_private_key(private_key: str) -> bool:
     try:
         key_api.PrivateKey(decode_hex(private_key)).public_key.to_address()
         return True  # noqa: TRY300
     except Exception:
         return False
+
+
+def is_address(address: str) -> bool:
+    return eth_utils.is_address(address)

mm_eth-0.3.1/src/mm_eth/cli/calcs.py

@@ -0,0 +1,93 @@
+import random
+
+import mm_crypto_utils
+from mm_crypto_utils import VarInt
+
+from mm_eth.constants import SUFFIX_DECIMALS
+
+
+def calc_eth_expression(expression: str, var: VarInt | None = None) -> int:
+    return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals=SUFFIX_DECIMALS)
+
+
+# def calc_var_value(value: str, *, var_name: str = "var", var_value: int | None = None, decimals: int | None = None) -> int:
+#     if not isinstance(value, str):
+#         raise TypeError(f"value is not str: {value}")
+#     try:
+#         var_name = var_name.lower()
+#         result = 0
+#         for token in split_on_plus_minus_tokens(value.lower()):
+#             operator = token[0]
+#             item = token[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("var_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"illegal ee: {value}, error={err}") from err
+
+
+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 :]
+
+
+# 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 < calc_eth_expression(value_min_limit):
+#         prefix = get_log_prefix(log_prefix)
+#         logger.info("{}value is less min limit, value={}", prefix, from_wei_str(value, value_unit, decimals=decimals))
+#         return True
+#     return False

{mm_eth-0.2.5 → mm_eth-0.3.1}/src/mm_eth/cli/cli.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from pathlib import Path
 from typing import Annotated
 
 import typer
@@ -21,8 +22,15 @@ from .cmd import (
     token_cmd,
     transfer_erc20_cmd,
     transfer_eth_cmd,
+    tx_cmd,
     vault_cmd,
 )
+from .cmd.balances_cmd import BalancesCmdParams
+from .cmd.call_contract_cmd import CallContractCmdParams
+from .cmd.deploy_cmd import DeployCmdParams
+from .cmd.send_contract_cmd import SendContractCmdParams
+from .cmd.transfer_erc20_cmd import TransferErc20CmdParams
+from .cmd.transfer_eth_cmd import TransferEthCmdParams
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
@@ -42,7 +50,7 @@ class ConfigExample(str, Enum):
 def balance_command(
     wallet_address: Annotated[str, typer.Argument()],
     token_address: Annotated[str | None, typer.Option("--token", "-t")] = None,
-    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL")] = "",  # nosec
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_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:
@@ -52,7 +60,7 @@ def balance_command(
 @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")] = "",
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL")] = "",
 ) -> None:
     token_cmd.run(rpc_url, token_address)
 
@@ -109,7 +117,7 @@ def vault_command(
         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")],
+    keys_file: Annotated[Path, typer.Option(..., "--file", "-f", help="Path to a file with private keys")],
 ) -> None:
     vault_cmd.run(keys_url, vault_token, keys_file)
 
@@ -118,15 +126,24 @@ def vault_command(
 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")] = "",
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_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="tx", help="Get transaction info by hash")
+def tx_command(
+    tx_hash: Annotated[str, typer.Argument()],
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL", help="RPC node url")] = "",
+    get_receipt: Annotated[bool, typer.Option("--receipt", "-r", help="Get receipt")] = False,
+) -> None:
+    tx_cmd.run(rpc_url, tx_hash, get_receipt)
+
+
 @app.command(name="transfer-eth", help="Transfer eth / base token from one or many accounts")
 def transfer_eth_command(
-    config_path: str,
+    config_path: Path,
     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"),
@@ -134,18 +151,20 @@ def transfer_eth_command(
     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,
+        TransferEthCmdParams(
+            config_path=config_path,
+            print_balances=print_balances,
+            print_config_and_exit=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,
+    config_path: Path,
     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"),
@@ -153,18 +172,20 @@ def transfer_erc20_command(
     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,
+        TransferErc20CmdParams(
+            config_path=config_path,
+            print_balances=print_balances,
+            print_config_and_exit=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,
+    config_path: Path,
     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"),
@@ -172,39 +193,41 @@ def send_contract_command(
     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,
+        SendContractCmdParams(
+            config_path=config_path,
+            print_balances=print_balances,
+            print_config_and_exit=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"),
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config 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)
+    balances_cmd.run(BalancesCmdParams(config_path=config_path, print_config_and_exit=print_config, wei=wei, show_nonce=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"),
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
 ) -> None:
-    call_contract_cmd.run(config_path, print_config)
+    call_contract_cmd.run(CallContractCmdParams(config_path=config_path, print_config_and_exit=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"),
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
 ) -> None:
-    deploy_cmd.run(config_path, print_config=print_config)
+    deploy_cmd.run(DeployCmdParams(config_path=config_path, print_config_and_exit=print_config))
 
 
 @app.command(name="config-example", help="Print an example of config for a command")
@@ -214,17 +237,17 @@ def config_example_command(command: Annotated[ConfigExample, typer.Argument()])
 
 @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)"),
+    function_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)
+    encode_input_data_cmd.run(function_signature, args_str)
 
 
 def version_callback(value: bool) -> None:
     if value:
-        print_plain(f"mm-eth-cli version: {cli_utils.get_version()}")
+        print_plain(f"mm-eth: {cli_utils.get_version()}")
         raise typer.Exit
 
 

mm_eth-0.3.1/src/mm_eth/cli/cli_utils.py

@@ -0,0 +1,32 @@
+import importlib.metadata
+from pathlib import Path
+
+from pydantic import BaseModel
+
+
+def get_version() -> str:
+    return importlib.metadata.version("mm-eth")
+
+
+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 "mainnet" | "1":
+            return "https://ethereum.publicnode.com"
+        case "opbnb" | "204":
+            return "https://opbnb-mainnet-rpc.bnbchain.org"
+        case "base" | "8453":
+            return "https://mainnet.base.org"
+        case "base-sepolia" | "84532":
+            return "https://sepolia.base.org"
+        case _:
+            return url
+
+
+class BaseConfigParams(BaseModel):
+    config_path: Path
+    print_config_and_exit: bool

{mm_eth-0.2.5 → mm_eth-0.3.1}/src/mm_eth/cli/cmd/balance_cmd.py

@@ -48,4 +48,4 @@ def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool,
         print_plain(f"token_balance: {balance}", print_format)
         json_result["token_balance"] = balance
 
-    print_json(json_result, print_format)
+    print_json(json_result, print_format=print_format)

{mm_eth-0.2.5 → mm_eth-0.3.1}/src/mm_eth/cli/cmd/balances_cmd.py

@@ -1,29 +1,23 @@
 from dataclasses import dataclass
+from typing import Annotated
 
 from mm_std import BaseConfig, Err, Ok, fatal
-from pydantic import Field, field_validator
+from pydantic import BeforeValidator
 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.cli.cli_utils import BaseConfigParams
+from mm_eth.cli.validators import Validators
 from mm_eth.utils import from_token_wei_str, from_wei_str
 
 
 class Config(BaseConfig):
-    addresses: list[str]
-    tokens: list[str] = Field(default_factory=list)
-    nodes: list[str]
+    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())]
     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:
@@ -32,17 +26,23 @@ class Token:
     symbol: str
 
 
-def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> None:
-    config = Config.read_config_or_exit(config_path)
-    cli_utils.print_config_and_exit(print_config, config)
+class BalancesCmdParams(BaseConfigParams):
+    wei: bool
+    show_nonce: bool
+
+
+def run(params: BalancesCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(params.config_path)
+    if params.print_config_and_exit:
+        config.print_and_exit()
 
     tokens = _get_tokens_info(config)
 
     table = Table(title="balances")
     table.add_column("address")
-    if show_nonce:
+    if params.show_nonce:
         table.add_column("nonce")
-    table.add_column("wei" if wei else "eth")
+    table.add_column("wei" if params.wei else "eth")
     for t in tokens:
         table.add_column(t.symbol)
 
@@ -51,13 +51,13 @@ def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> No
     with Live(table, refresh_per_second=0.5):
         for address in config.addresses:
             row = [address]
-            if show_nonce:
+            if params.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:
+                if params.wei:
                     row.append(str(base_balance_res.ok))
                 else:
                     row.append(
@@ -70,7 +70,7 @@ def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> No
                 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:
+                    if params.wei:
                         row.append(str(token_balance_res.ok))
                     else:
                         row.append(
@@ -86,9 +86,9 @@ def run(config_path: str, print_config: bool, wei: bool, show_nonce: bool) -> No
             table.add_row(*row)
 
         sum_row = ["sum"]
-        if show_nonce:
+        if params.show_nonce:
             sum_row.append("")
-        if wei:
+        if params.wei:
             sum_row.append(str(base_sum))
             sum_row.extend([str(token_sum[t.address]) for t in tokens])
         else:

{mm_eth-0.2.5 → mm_eth-0.3.1}/src/mm_eth/cli/cmd/call_contract_cmd.py

@@ -5,7 +5,7 @@ from mm_std import BaseConfig, Err, print_plain
 from pydantic import StrictStr
 
 from mm_eth import abi, rpc
-from mm_eth.cli import cli_utils
+from mm_eth.cli.cli_utils import BaseConfigParams
 
 
 class Config(BaseConfig):
@@ -16,9 +16,14 @@ class Config(BaseConfig):
     node: str
 
 
-def run(config_path: str, print_config: bool) -> None:
-    config = Config.read_config_or_exit(config_path)
-    cli_utils.print_config_and_exit(print_config, config)
+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_and_exit:
+        config.print_and_exit()
 
     input_data = abi.encode_function_input_by_signature(
         config.function_signature,

{mm_eth-0.2.5 → mm_eth-0.3.1}/src/mm_eth/cli/cmd/config_example_cmd.py

@@ -5,5 +5,5 @@ 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")
+    example_file = Path(Path(__file__).parent.absolute(), "../config_examples", f"{command}.toml")
     print_plain(example_file.read_text())

{mm_eth-0.2.5 → mm_eth-0.3.1}/src/mm_eth/cli/cmd/deploy_cmd.py

@@ -3,7 +3,8 @@ from mm_std import BaseConfig, fatal
 from pydantic import StrictStr
 
 from mm_eth import account, deploy
-from mm_eth.cli import cli_utils, rpc_helpers
+from mm_eth.cli import rpc_helpers
+from mm_eth.cli.cli_utils import BaseConfigParams
 
 
 class Config(BaseConfig):
@@ -20,9 +21,14 @@ class Config(BaseConfig):
     node: str
 
 
-def run(config_path: str, *, print_config: bool) -> None:
-    config = Config.read_config_or_exit(config_path)
-    cli_utils.print_config_and_exit(print_config, config, {"private_key"})
+class DeployCmdParams(BaseConfigParams):
+    pass
+
+
+def run(cli_params: DeployCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(cli_params.config_path)
+    if cli_params.print_config_and_exit:
+        config.print_and_exit({"private_key"})
 
     constructor_types = yaml.full_load(config.constructor_types)
     constructor_values = yaml.full_load(config.constructor_values)

{mm_eth-0.2.5 → mm_eth-0.3.1}/src/mm_eth/cli/cmd/node_cmd.py

@@ -44,4 +44,4 @@ def run(urls: list[str], print_format: PrintFormat, proxy: str | None) -> None:
             print_plain(f"base_fee: {base_fee}", print_format)
             print_plain("", print_format)
 
-    print_json(json_result, print_format)
+    print_json(json_result, print_format=print_format)