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

mm_eth/cli/cmd/solc_cmd.py

@@ -1,25 +1,29 @@
+"""CLI command: compile Solidity contracts."""
+
 import json
 from pathlib import Path
 
-import mm_print
+from mm_print import print_json, print_plain
 
 from mm_eth.cli.cli import PrintFormat
+from mm_eth.cli.cli_utils import fatal
 from mm_eth.solc import solc
 
 
 def run(contract_path: Path, tmp_dir: Path, print_format: PrintFormat) -> None:
+    """Compile a Solidity file and print the ABI and bytecode."""
     contract_name = contract_path.stem
     res = solc(contract_name, contract_path, tmp_dir)
     if res.is_err():
-        mm_print.exit_with_error(res.unwrap_err())
+        fatal(res.unwrap_err())
 
     bin_ = res.unwrap().bin
     abi = res.unwrap().abi
 
     if print_format == PrintFormat.JSON:
-        mm_print.json({"bin": bin_, "abi": json.loads(abi)})
+        print_json({"bin": bin_, "abi": json.loads(abi)})
     else:
-        mm_print.plain("bin:")
-        mm_print.plain(bin_)
-        mm_print.plain("abi:")
-        mm_print.plain(abi)
+        print_plain("bin:")
+        print_plain(bin_)
+        print_plain("abi:")
+        print_plain(abi)

mm_eth/cli/cmd/transfer_cmd.py

@@ -1,3 +1,5 @@
+"""CLI command: transfer ETH or ERC-20 tokens."""
+
 import asyncio
 import sys
 import time
@@ -20,6 +22,8 @@ from mm_eth.converters import from_wei
 
 
 class Config(Web3CliConfig):
+    """Configuration for the transfer command."""
+
     nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
     chain_id: int
     transfers: Annotated[list[Transfer], BeforeValidator(Validators.eth_transfers())]
@@ -41,10 +45,12 @@ class Config(Web3CliConfig):
 
     @property
     def from_addresses(self) -> list[str]:
+        """Return the list of sender addresses from all transfers."""
         return [r.from_address for r in self.transfers]
 
     @model_validator(mode="after")
     def final_validator(self) -> Self:
+        """Validate private keys coverage, set default values, and check expression types."""
         if not self.private_keys.contains_all_addresses(self.from_addresses):
             raise ValueError("private keys are not set for all addresses")
 
@@ -69,6 +75,7 @@ class Config(Web3CliConfig):
         return self
 
     async def async_init(self) -> None:
+        """Fetch token decimals from the network if a token address is configured."""
         if self.token:
             self.token_decimals = (await retry.erc20_decimals(5, self.nodes, self.proxies, token=self.token)).unwrap(
                 "can't get token decimals"
@@ -76,6 +83,8 @@ class Config(Web3CliConfig):
 
 
 class TransferCmdParams(BaseConfigParams):
+    """Parameters for the transfer command."""
+
     print_balances: bool
     print_transfers: bool
     debug: bool
@@ -84,6 +93,7 @@ class TransferCmdParams(BaseConfigParams):
 
 
 async def run(params: TransferCmdParams) -> None:
+    """Read config and execute transfers, or print balances/transfers for inspection."""
     config = await Config.read_toml_config_or_exit_async(params.config_path)
     await config.async_init()
     if params.print_config:
@@ -103,6 +113,7 @@ async def run(params: TransferCmdParams) -> None:
 
 
 async def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
+    """Execute all configured transfers sequentially with optional delays."""
     init_loguru(cmd_params.debug, config.log_debug, config.log_info)
     logger.info(f"transfer {cmd_params.config_path}: started at {utc_now()} UTC")
     logger.debug(f"config={config.model_dump(exclude={'private_keys'}) | {'version': cli_utils.get_version()}}")
@@ -117,6 +128,7 @@ async def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
 
 
 async def _get_nonce(t: Transfer, config: Config) -> int | None:
+    """Fetch the nonce for the transfer's sender address."""
     res = await retry.eth_get_transaction_count(5, config.nodes, config.proxies, address=t.from_address)
     if res.is_err():
         logger.error(f"{t.log_prefix}: nonce error: {res.unwrap_err()}")
@@ -126,6 +138,7 @@ async def _get_nonce(t: Transfer, config: Config) -> int | None:
 
 
 async def _calc_max_fee(t: Transfer, config: Config) -> int | None:
+    """Calculate the max fee, fetching base_fee from the network if needed."""
     if "base_fee" in config.max_fee.lower():
         base_fee_res = await retry.get_base_fee_per_gas(5, config.nodes, config.proxies)
         if base_fee_res.is_err():
@@ -137,6 +150,7 @@ async def _calc_max_fee(t: Transfer, config: Config) -> int | None:
 
 
 def check_max_fee_limit(t: Transfer, config: Config, max_fee: int) -> bool:
+    """Return False if max_fee exceeds the configured limit."""
     if config.max_fee_limit:
         max_fee_limit = calcs.calc_eth_expression(config.max_fee_limit)
         if max_fee > max_fee_limit:
@@ -148,6 +162,7 @@ def check_max_fee_limit(t: Transfer, config: Config, max_fee: int) -> bool:
 
 
 async def _calc_gas(t: Transfer, config: Config) -> int | None:
+    """Calculate the gas limit, optionally using on-chain estimation."""
     variables: dict[str, int] | None = None
     if "estimate" in config.gas.lower():
         if config.token:
@@ -172,6 +187,7 @@ async def _calc_gas(t: Transfer, config: Config) -> int | None:
 
 
 async def _calc_eth_value(t: Transfer, max_fee: int, gas: int, config: Config) -> int | None:
+    """Calculate the ETH transfer value, subtracting gas costs if using balance."""
     value_expression = t.value.lower()
     variables: dict[str, int] | None = None
     if "balance" in value_expression:
@@ -189,6 +205,7 @@ async def _calc_eth_value(t: Transfer, max_fee: int, gas: int, config: Config) -
 
 
 async def _calc_token_value(t: Transfer, config: Config) -> int | None:
+    """Calculate the ERC-20 token transfer value from a value expression."""
     value_expression = t.value.lower()
     variables: dict[str, int] | None = None
     if "balance" in value_expression:
@@ -202,13 +219,14 @@ async def _calc_token_value(t: Transfer, config: Config) -> int | None:
 
 
 async def _calc_value(t: Transfer, max_fee: int, gas: int, config: Config) -> int | None:
+    """Calculate the transfer value, dispatching to ETH or token calculation."""
     if config.token:
         return await _calc_token_value(t, config)
     return await _calc_eth_value(t, max_fee, gas, config)
 
 
 def _check_value_min_limit(t: Transfer, value: int, config: Config) -> bool:
-    """Returns False if the transfer should be skipped."""
+    """Return False if the transfer should be skipped."""
     if config.value_min_limit:
         if config.token:
             value_min_limit = calcs.calc_token_expression(config.value_min_limit, config.token_decimals)
@@ -220,6 +238,7 @@ def _check_value_min_limit(t: Transfer, value: int, config: Config) -> bool:
 
 
 async def _transfer(t: Transfer, config: Config, cmd_params: TransferCmdParams) -> None:
+    """Execute a single transfer: calculate params, sign, send, and wait for receipt."""
     nonce = await _get_nonce(t, config)
     if nonce is None:
         return
@@ -268,6 +287,7 @@ async def _transfer(t: Transfer, config: Config, cmd_params: TransferCmdParams)
 
 
 async def wait_tx_status(t: Transfer, tx_hash: str, config: Config) -> Literal["OK", "FAIL", "TIMEOUT"]:
+    """Poll for a transaction receipt until success, failure, or timeout."""
     logger.debug(f"{t.log_prefix}: waiting for receipt, tx_hash={tx_hash}")
     started_at = time.perf_counter()
     count = 0
@@ -286,6 +306,7 @@ async def wait_tx_status(t: Transfer, tx_hash: str, config: Config) -> Literal["
 async def _send_tx(
     *, transfer: Transfer, nonce: int, max_fee: int, priority_fee: int, gas: int, value: int, config: Config
 ) -> str | None:
+    """Sign and broadcast a transaction, returning the tx hash or None on failure."""
     debug_tx_params = {
         "nonce": nonce,
         "max_fee": max_fee,
@@ -330,6 +351,7 @@ async def _send_tx(
 
 
 def _print_transfers(config: Config) -> None:
+    """Print the configured transfers as a table."""
     table = Table("n", "from_address", "to_address", "value", title="transfers")
     for count, transfer in enumerate(config.transfers, start=1):
         table.add_row(str(count), transfer.from_address, transfer.to_address, transfer.value)
@@ -338,6 +360,7 @@ def _print_transfers(config: Config) -> None:
 
 
 async def _print_balances(config: Config) -> None:
+    """Fetch and print ETH (and token) balances for all transfer routes."""
     if config.token:
         headers = ["n", "from_address", "nonce", "eth", "t", "to_address", "nonce", "eth", "t"]
     else:
@@ -414,6 +437,7 @@ async def _print_balances(config: Config) -> None:
 
 
 def _value_with_suffix(value: int, config: Config) -> str:
+    """Format a value with its unit suffix (eth or t) for display."""
     if config.token:
         return f"{from_wei(value, 't', config.round_ndigits, decimals=config.token_decimals)}t"
     return f"{from_wei(value, 'eth', config.round_ndigits)}eth"

mm_eth/cli/cmd/wallet/__init__.py

@@ -0,0 +1 @@
+"""Wallet-related CLI commands."""

mm_eth/cli/cmd/wallet/mnemonic_cmd.py

@@ -1,12 +1,15 @@
+"""CLI command: generate or derive accounts from a mnemonic."""
+
 from pathlib import Path
 from typing import Any
 
-import mm_print
+from mm_print import print_json
 
 from mm_eth.account import derive_accounts, generate_mnemonic
 
 
 def run(mnemonic: str, passphrase: str, words: int, derivation_path: str, limit: int, print_path: bool, save_file: str) -> None:  # nosec
+    """Generate a mnemonic (if not provided) and derive accounts from it."""
     result: dict[str, Any] = {}
     if not mnemonic:
         mnemonic = generate_mnemonic(num_words=words)
@@ -19,7 +22,7 @@ def run(mnemonic: str, passphrase: str, words: int, derivation_path: str, limit:
         if print_path:
             new_account["path"] = acc.path
         result["accounts"].append(new_account)
-    mm_print.json(result)
+    print_json(result)
 
     if save_file:
         data = [acc["address"] + "\t" + acc["private"] for acc in result["accounts"]]

mm_eth/cli/cmd/wallet/private_key_cmd.py

@@ -1,11 +1,15 @@
-import mm_print
+"""CLI command: derive address from a private key."""
+
+from mm_print import print_plain
 
 from mm_eth import account
+from mm_eth.cli.cli_utils import fatal
 
 
 def run(private_key: str) -> None:
+    """Print the Ethereum address for the given private key."""
     res = account.private_to_address(private_key)
     if res.is_ok():
-        mm_print.plain(res.unwrap())
+        print_plain(res.unwrap())
     else:
-        mm_print.exit_with_error(f"invalid private key: '{private_key}'")
+        fatal(f"invalid private key: '{private_key}'")

mm_eth/cli/rpc_helpers.py

@@ -1,3 +1,5 @@
+"""RPC helper functions with logging for CLI commands."""
+
 import logging
 
 from mm_web3 import Nodes, Proxies
@@ -11,6 +13,7 @@ logger = logging.getLogger(__name__)
 async def get_nonce_with_logging(
     log_prefix: str | None, retries: int, nodes: Nodes, proxies: Proxies, *, address: str
 ) -> int | None:
+    """Fetch the nonce for an address, logging errors and debug info."""
     res = await retry.eth_get_transaction_count(retries, nodes, proxies, address=address)
     prefix = log_prefix or address
     if res.is_err():
@@ -21,6 +24,7 @@ async def get_nonce_with_logging(
 
 
 async def get_base_fee_with_logging(log_prefix: str | None, retries: int, nodes: Nodes, proxies: Proxies) -> int | None:
+    """Fetch the base fee, logging errors and debug info."""
     prefix = get_log_prefix(log_prefix)
     res = await retry.get_base_fee_per_gas(retries, nodes, proxies)
     if res.is_err():
@@ -34,6 +38,7 @@ async def get_base_fee_with_logging(log_prefix: str | None, retries: int, nodes:
 async def calc_max_fee_with_logging(
     log_prefix: str | None, retries: int, nodes: Nodes, proxies: Proxies, *, max_fee_expression: str
 ) -> int | None:
+    """Evaluate a max fee expression, fetching base_fee from the network if needed."""
     if "base_fee" in max_fee_expression.lower():
         base_fee = await get_base_fee_with_logging(log_prefix, retries, nodes, proxies)
         if base_fee is None:
@@ -44,6 +49,7 @@ async def calc_max_fee_with_logging(
 
 
 def get_log_prefix(log_prefix: str | None) -> str:
+    """Format a log prefix string, appending ': ' if non-empty."""
     prefix = log_prefix or ""
     if prefix:
         prefix += ": "

mm_eth/cli/validators.py

@@ -1,3 +1,5 @@
+"""Pydantic validators for Ethereum addresses, keys, and expressions."""
+
 from collections.abc import Callable
 
 import eth_utils
@@ -9,6 +11,7 @@ SUFFIX_DECIMALS = {"eth": 18, "gwei": 9, "ether": 18}
 
 
 def address_from_private(private_key: str) -> str:
+    """Derive a lowercase Ethereum address from a private key."""
     res = account.private_to_address(private_key)
     if res.is_err():
         raise ValueError("invalid private key")
@@ -16,30 +19,39 @@ def address_from_private(private_key: str) -> str:
 
 
 class Validators(ConfigValidators):
+    """Ethereum-specific config validators for addresses, keys, and expressions."""
+
     @staticmethod
     def valid_eth_expression(var_name: str | None = None) -> Callable[[str], str]:
+        """Return a validator for expressions with ETH unit suffixes."""
         return ConfigValidators.expression_with_vars(var_name, SUFFIX_DECIMALS)
 
     @staticmethod
     def valid_token_expression(var_name: str | None = None) -> Callable[[str], str]:
+        """Return a validator for expressions with token unit suffix."""
         return ConfigValidators.expression_with_vars(var_name, {"t": 6})
 
     @staticmethod
     def valid_eth_or_token_expression(var_name: str | None = None) -> Callable[[str], str]:
+        """Return a validator for expressions with ETH or token unit suffixes."""
         return ConfigValidators.expression_with_vars(var_name, SUFFIX_DECIMALS | {"t": 6})
 
     @staticmethod
     def eth_transfers() -> Callable[[str], list[Transfer]]:
+        """Return a validator for Ethereum transfer definitions."""
         return ConfigValidators.transfers(is_address=eth_utils.is_address, lowercase=True)
 
     @staticmethod
     def eth_private_keys() -> Callable[[str], PrivateKeyMap]:
+        """Return a validator for Ethereum private key mappings."""
         return ConfigValidators.private_keys(address_from_private)
 
     @staticmethod
     def eth_address() -> Callable[[str], str]:
+        """Return a validator for a single Ethereum address."""
         return ConfigValidators.address(eth_utils.is_address, lowercase=True)
 
     @staticmethod
     def eth_addresses(unique: bool) -> Callable[[str], list[str]]:
+        """Return a validator for a list of Ethereum addresses."""
         return ConfigValidators.addresses(unique, lowercase=True, is_address=eth_utils.is_address)

mm_eth/converters.py

@@ -1,3 +1,5 @@
+"""Wei/ether/gwei/token unit conversion utilities."""
+
 from decimal import Decimal, localcontext
 from typing import cast
 
@@ -6,6 +8,7 @@ from web3.types import Wei
 
 
 def to_wei(value: str | int | Decimal, decimals: int | None = None) -> Wei:
+    """Convert a value with optional unit suffix (gwei, ether, eth, t) to wei."""
     if isinstance(value, int):
         return Wei(value)
     if isinstance(value, Decimal):
@@ -36,6 +39,7 @@ def to_wei(value: str | int | Decimal, decimals: int | None = None) -> Wei:
 
 
 def from_wei(value: int, unit: str, round_ndigits: int | None = None, decimals: int | None = None) -> Decimal:
+    """Convert a wei value to the specified unit (eth, gwei, t) with optional rounding."""
     if value == 0:
         return Decimal(0)
 

mm_eth/deploy.py

@@ -1,3 +1,5 @@
+"""Smart contract deployment helpers."""
+
 import eth_utils
 import rlp
 from eth_utils import keccak
@@ -6,6 +8,7 @@ from mm_eth import abi
 
 
 def get_deploy_contract_data(contract_bin: str, constructor_types: list[str], constructor_values: list[object]) -> str:
+    """Build deployment bytecode by appending ABI-encoded constructor arguments to contract binary."""
     constructor_data = ""
     if constructor_types and constructor_values:
         constructor_data = abi.encode_data(constructor_types, constructor_values)[2:]
@@ -13,6 +16,7 @@ def get_deploy_contract_data(contract_bin: str, constructor_types: list[str], co
 
 
 def get_contract_address(sender_address: str, nonce: int) -> str:
+    """Compute the contract address that would be created by a given sender and nonce."""
     sender_bytes = eth_utils.to_bytes(hexstr=sender_address)
     raw = rlp.encode([sender_bytes, nonce])
     h = keccak(raw)

mm_eth/erc20.py

@@ -1,3 +1,5 @@
+"""ERC-20 token transfer encoding and signing."""
+
 import eth_abi
 import eth_utils
 from eth_typing import HexStr
@@ -10,6 +12,7 @@ TRANSFER_TOPIC = HexStr("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55
 
 
 def encode_transfer_input_data(recipient: str, value: int) -> str:
+    """Encode ERC-20 transfer(address,uint256) call data."""
     recipient = eth_utils.to_checksum_address(recipient)
     input_data = eth_utils.to_bytes(hexstr=HexStr(TRANSFER_METHOD)) + eth_abi.encode(["address", "uint256"], [recipient, value])
     return eth_utils.to_hex(input_data)
@@ -27,6 +30,7 @@ def sign_transfer_tx(
     private_key: str,
     chain_id: int,
 ) -> SignedTx:
+    """Sign an ERC-20 transfer transaction (EIP-1559)."""
     input_data = encode_transfer_input_data(recipient_address, value)
     return tx.sign_tx(
         nonce=nonce,

mm_eth/retry.py

@@ -1,3 +1,5 @@
+"""Retry-enabled wrappers around RPC calls using node and proxy rotation."""
+
 from typing import Any, Literal
 
 from eth_typing import BlockIdentifier
@@ -14,18 +16,21 @@ TIMEOUT = 5.0
 
 
 async def eth_block_number(retries: int, nodes: Nodes, proxies: Proxies, *, timeout: float = TIMEOUT) -> Result[int]:
+    """Return the current block number with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.eth_block_number(node, timeout, proxy)
     )
 
 
 async def eth_get_balance(retries: int, nodes: Nodes, proxies: Proxies, *, address: str, timeout: float = TIMEOUT) -> Result[int]:
+    """Return the ETH balance of an address with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.eth_get_balance(node, address, timeout, proxy)
     )
 
 
 async def eth_chain_id(retries: int, nodes: Nodes, proxies: Proxies, *, timeout: float = TIMEOUT) -> Result[int]:
+    """Return the chain ID with retry logic."""
     return await retry_with_node_and_proxy(retries, nodes, proxies, lambda node, proxy: rpc.eth_chain_id(node, timeout, proxy))
 
 
@@ -38,6 +43,7 @@ async def eth_get_block_by_number(
     full_transaction: bool = False,
     timeout: float = TIMEOUT,
 ) -> Result[dict[str, Any]]:
+    """Return block data for a given block number with retry logic."""
     return await retry_with_node_and_proxy(
         retries,
         nodes,
@@ -49,6 +55,7 @@ async def eth_get_block_by_number(
 async def eth_get_transaction_count(
     retries: int, nodes: Nodes, proxies: Proxies, *, address: str, timeout: float = TIMEOUT
 ) -> Result[int]:
+    """Return the nonce for an address with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.eth_get_transaction_count(node, address, timeout, proxy)
     )
@@ -66,6 +73,7 @@ async def eth_estimate_gas(
     type_: Literal["0x0", "0x2"] | None = None,
     timeout: float = TIMEOUT,
 ) -> Result[int]:
+    """Estimate gas for a transaction with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.eth_estimate_gas(node, from_, to, value, data, type_, timeout, proxy)
     )
@@ -74,6 +82,7 @@ async def eth_estimate_gas(
 async def eth_send_raw_transaction(
     retries: int, nodes: Nodes, proxies: Proxies, *, raw_tx: str, timeout: float = TIMEOUT
 ) -> Result[str]:
+    """Broadcast a raw transaction with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.eth_send_raw_transaction(node, raw_tx, timeout, proxy)
     )
@@ -82,6 +91,7 @@ async def eth_send_raw_transaction(
 async def eth_get_transaction_receipt(
     retries: int, nodes: Nodes, proxies: Proxies, *, tx_hash: str, timeout: float = TIMEOUT
 ) -> Result[TxReceipt]:
+    """Fetch a transaction receipt with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.eth_get_transaction_receipt(node, tx_hash, timeout, proxy)
     )
@@ -96,6 +106,7 @@ async def eth_get_transaction_receipt(
 async def erc20_balance(
     retries: int, nodes: Nodes, proxies: Proxies, *, token: str, wallet: str, timeout: float = TIMEOUT
 ) -> Result[int]:
+    """Return an ERC-20 token balance with retry logic."""
     return await retry_with_node_and_proxy(
         retries,
         nodes,
@@ -105,18 +116,21 @@ async def erc20_balance(
 
 
 async def erc20_name(retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = TIMEOUT) -> Result[str]:
+    """Return the name of an ERC-20 token with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.erc20_name(node, token, timeout, proxy)
     )
 
 
 async def erc20_symbol(retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = TIMEOUT) -> Result[str]:
+    """Return the symbol of an ERC-20 token with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.erc20_symbol(node, token, timeout, proxy)
     )
 
 
 async def erc20_decimals(retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = TIMEOUT) -> Result[int]:
+    """Return the decimals of an ERC-20 token with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.erc20_decimals(node, token, timeout, proxy)
     )
@@ -128,6 +142,7 @@ async def erc20_decimals(retries: int, nodes: Nodes, proxies: Proxies, *, token:
 
 
 async def ens_name(retries: int, nodes: Nodes, proxies: Proxies, *, address: str, timeout: float = TIMEOUT) -> Result[str | None]:
+    """Perform reverse ENS resolution with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.ens_name(node, address, timeout, proxy)
     )
@@ -139,12 +154,14 @@ async def ens_name(retries: int, nodes: Nodes, proxies: Proxies, *, address: str
 
 
 async def get_base_fee_per_gas(retries: int, nodes: Nodes, proxies: Proxies, *, timeout: float = TIMEOUT) -> Result[int]:
+    """Return the base fee per gas from the latest block with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.get_base_fee_per_gas(node, timeout, proxy)
     )
 
 
 async def get_tx_status(retries: int, nodes: Nodes, proxies: Proxies, *, tx_hash: str, timeout: float = TIMEOUT) -> Result[int]:
+    """Return the transaction status (0=fail, 1=success) with retry logic."""
     return await retry_with_node_and_proxy(
         retries, nodes, proxies, lambda node, proxy: rpc.get_tx_status(node, tx_hash, timeout, proxy)
     )