mm-strk 0.4.2__tar.gz → 0.5.0__tar.gz

mm_strk-0.5.0/.claude/settings.local.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(just lint:*)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:docs.starknet.io)",
+      "Bash(curl:*)",
+      "WebFetch(domain:www.starknet.io)",
+      "WebFetch(domain:www.comparenodes.com)",
+      "WebFetch(domain:starknetpy.readthedocs.io)",
+      "WebFetch(domain:pypi.org)",
+      "WebFetch(domain:drpc.org)"
+    ]
+  }
+}

mm_strk-0.5.0/ADR.md

@@ -0,0 +1,3 @@
+# Architecture Decision Records
+
+Key design decisions for this project. Read this before suggesting changes.

mm_strk-0.5.0/CLAUDE.md

@@ -0,0 +1,24 @@
+# AI Agent Start Guide
+
+## Critical: Language
+RESPOND IN ENGLISH. Always. No exceptions.
+User's language does NOT determine your response language.
+Only switch if user EXPLICITLY requests it (e.g., "respond in {language}").
+Language switching applies ONLY to chat. All code, comments, commit messages, and files must ALWAYS be in English — no exceptions.
+
+## Mandatory Rules (external)
+These files are REQUIRED. Read them fully and follow all rules.
+- `~/.claude/shared-rules/general.md`
+- `~/.claude/shared-rules/python.md`
+
+## Project Reading (context)
+These files are REQUIRED for project understanding.
+- `README.md`
+
+## Preflight (mandatory)
+Before your first response:
+1. Read all files listed above.
+2. Do not answer until all are read.
+3. In your first reply, list every file you have read from this document.
+
+Failure to follow this protocol is considered an error.

mm_strk-0.5.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mm-strk
+Version: 0.5.0
+Requires-Python: >=3.14
+Requires-Dist: mm-web3~=0.6.2
+Requires-Dist: starknet-py~=0.29.0
+Requires-Dist: typer~=0.21.1

mm_strk-0.5.0/README.md

@@ -0,0 +1,72 @@
+# mm-strk
+
+Starknet utilities library.
+
+**Requires RPC node version 0.9+**
+
+## Installation
+
+```bash
+pip install mm-strk
+```
+
+## API
+
+### is_address
+
+Validates a Starknet address.
+
+```python
+from mm_strk.account import is_address
+
+is_address("0x123abc")  # True - minimal form
+is_address("0x0000000000000000000000000000000000000000000000000000000000123abc")  # True - full 64-char form
+is_address("invalid")  # False
+```
+
+### get_balance
+
+Queries token balance for an address.
+
+```python
+import asyncio
+from mm_strk.balance import get_balance, ETH_ADDRESS_MAINNET, STRK_ADDRESS_MAINNET
+
+result = asyncio.run(get_balance(
+    rpc_url="https://your-rpc-node.com",
+    address="0x123...",
+    token=ETH_ADDRESS_MAINNET,
+))
+if result.is_ok():
+    print(result.ok)  # balance in wei
+```
+
+Token constants:
+- `ETH_ADDRESS_MAINNET`, `ETH_DECIMALS` (18)
+- `STRK_ADDRESS_MAINNET`, `STRK_DECIMALS` (18)
+- `USDC_ADDRESS_MAINNET`, `USDC_DECIMALS` (6)
+- `USDT_ADDRESS_MAINNET`, `USDT_DECIMALS` (6)
+- `DAI_ADDRESS_MAINNET`, `DAI_DECIMALS` (18)
+
+### address_to_domain
+
+Resolves a Starknet address to its Starknet ID domain.
+
+```python
+import asyncio
+from mm_strk.domain import address_to_domain
+
+result = asyncio.run(address_to_domain("0x123..."))
+if result.is_ok():
+    print(result.ok)  # "example.stark" or None if not found
+```
+
+## CLI
+
+### mm-strk node
+
+Check status of Starknet RPC nodes.
+
+```bash
+mm-strk node https://rpc-node-1.com https://rpc-node-2.com
+```

{mm_strk-0.4.2 → mm_strk-0.5.0}/pyproject.toml

@@ -1,13 +1,9 @@
 [project]
 name = "mm-strk"
-version = "0.4.2"
+version = "0.5.0"
 description = ""
-requires-python = ">=3.13"
-dependencies = [
-    "mm-web3~=0.5.1",
-    "starknet-py~=0.27.0",
-    "typer>=0.16.0",
-]
+requires-python = ">=3.14"
+dependencies = ["mm-web3~=0.6.2", "starknet-py~=0.29.0", "typer~=0.21.1"]
 [project.scripts]
 mm-strk = "mm_strk.cli.cli:app"
 
@@ -17,29 +13,32 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 
-[tool.uv]
-dev-dependencies = [
-    "pytest~=8.4.0",
-    "pytest-asyncio~=1.0.0",
-    "pytest-xdist~=3.7.0",
-    "ruff~=0.11.13",
-    "pip-audit~=2.9.0",
-    "bandit~=1.8.3",
-    "mypy~=1.16.0",
-    "python-dotenv>=1.1.0",
+[dependency-groups]
+dev = [
+    "bandit~=1.9.3",
+    "mypy~=1.19.1",
+    "pip-audit~=2.10.0",
+    "pre-commit~=4.5.1",
+    "pytest~=9.0.2",
+    "pytest-asyncio~=1.3.0",
+    "pytest-xdist~=3.8.0",
+    "ruff~=0.15.0",
+    "python-dotenv~=1.2.0",
 ]
+
+[tool.uv]
 override-dependencies = ["pywin32 ; sys_platform == 'win32'"]
 
 
 [tool.mypy]
-python_version = "3.13"
+python_version = "3.14"
 warn_no_return = false
 strict = true
 exclude = ["^tests/", "^tmp/"]
 
 [tool.ruff]
 line-length = 130
-target-version = "py313"
+target-version = "py314"
 [tool.ruff.lint]
 select = ["ALL"]
 ignore = [
@@ -47,7 +46,6 @@ ignore = [
     "A005",     # flake8-builtins: stdlib-module-shadowing
     "ERA001",   # eradicate: commented-out-code
     "PT",       # flake8-pytest-style
-    "D",        # pydocstyle
     "FIX",      # flake8-fixme
     "PLR0911",  # pylint: too-many-return-statements
     "PLR0912",  # pylint: too-many-branches
@@ -65,6 +63,8 @@ ignore = [
     "RET503",   # flake8-return: implicit-return
     "COM812",   # it's used in ruff formatter
     "ASYNC109", # flake8-async: async-function-with-timeout
+    "D203",     # pydocstyle: one-blank-line-before-class (conflicts with D211)
+    "D213",     # pydocstyle: multi-line-summary-second-line (conflicts with D212)
 ]
 [tool.ruff.lint.pep8-naming]
 classmethod-decorators = ["field_validator"]

mm_strk-0.5.0/src/mm_strk/__init__.py

@@ -0,0 +1 @@
+"""Starknet utilities library."""

{mm_strk-0.4.2 → mm_strk-0.5.0}/src/mm_strk/account.py

@@ -1,3 +1,5 @@
+"""Starknet address validation."""
+
 import re
 
 # Maximum allowable value for a StarkNet address (251 bits)
@@ -5,15 +7,14 @@ MAX_STARKNET_ADDRESS = 2**251
 
 
 def is_address(address: str) -> bool:
-    """
-    Validates a StarkNet address.
+    """Validate a Starknet address.
 
     - Must be a string starting with '0x'.
     - Hex part 1-64 chars.
     - Integer value < 2**251.
     - Accepts either:
-      • Full 64-hex-character padded form.
-      • Minimal form without leading zeros (canonical).
+      * Full 64-hex-character padded form.
+      * Minimal form without leading zeros (canonical).
     """
     # Type and prefix
     if not isinstance(address, str) or not address.startswith("0x"):
@@ -39,5 +40,5 @@ def is_address(address: str) -> bool:
         return True
 
     # Minimal form (no leading zeros)
-    canonical = hex(value)[2:]
+    canonical = f"{value:x}"
     return hex_part.lower() == canonical

{mm_strk-0.4.2 → mm_strk-0.5.0}/src/mm_strk/balance.py

@@ -1,3 +1,5 @@
+"""Token balance querying on Starknet."""
+
 import aiohttp
 from aiohttp_socks import ProxyConnector
 from mm_result import Result
@@ -19,6 +21,7 @@ STRK_DECIMALS = 18
 
 
 async def get_balance(rpc_url: str, address: str, token: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
+    """Get token balance for a Starknet address."""
     try:
         timeout_config = aiohttp.ClientTimeout(total=timeout)
         connector = ProxyConnector.from_url(proxy) if proxy else None

mm_strk-0.5.0/src/mm_strk/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package for mm-strk."""

{mm_strk-0.4.2 → mm_strk-0.5.0}/src/mm_strk/cli/cli.py

@@ -1,7 +1,9 @@
+"""CLI entry point for mm-strk."""
+
 from typing import Annotated
 
-import mm_print
 import typer
+from mm_print import print_plain
 
 from mm_strk.cli import cli_utils, commands
 
@@ -9,14 +11,15 @@ app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_comp
 
 
 def version_callback(value: bool) -> None:
+    """Print version and exit when --version is passed."""
     if value:
-        mm_print.plain(f"mm-strk: {cli_utils.get_version()}")
+        print_plain(f"mm-strk: {cli_utils.get_version()}")
         raise typer.Exit
 
 
 @app.callback()
 def main(_version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=True)) -> None:
-    pass
+    """Starknet utilities CLI."""
 
 
 @app.command(name="node", help="Checks RPC URLs for availability and status")
@@ -24,4 +27,5 @@ def node_command(
     urls: Annotated[list[str], typer.Argument()],
     proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
 ) -> None:
+    """Check RPC node availability and status."""
     commands.node.run(urls, proxy)

{mm_strk-0.4.2 → mm_strk-0.5.0}/src/mm_strk/cli/cli_utils.py

@@ -1,5 +1,8 @@
+"""CLI utility functions."""
+
 import importlib.metadata
 
 
 def get_version() -> str:
+    """Return the installed version of mm-strk."""
     return importlib.metadata.version("mm-strk")

{mm_strk-0.4.2 → mm_strk-0.5.0}/src/mm_strk/cli/commands/__init__.py

@@ -1,3 +1,5 @@
+"""CLI commands for mm-strk."""
+
 from . import node
 
 __all__ = ["node"]

{mm_strk-0.4.2 → mm_strk-0.5.0}/src/mm_strk/cli/commands/node.py

@@ -1,19 +1,25 @@
+"""Starknet node status checking."""
+
 import asyncio
 
-import mm_print
 import typer
+from mm_print import print_json
 from pydantic import BaseModel
 from starknet_py.net.client_models import SyncStatus
 from starknet_py.net.full_node_client import FullNodeClient
 
 
 class NodeStatus(BaseModel):
+    """Starknet node status response."""
+
+    spec_version: str
     block_number: int | str
     chain_id: int | str
     syncing_status: bool | SyncStatus | str
 
 
 def run(urls: list[str], proxy: str | None) -> None:
+    """Check status of Starknet nodes."""
     if proxy:
         typer.echo("proxy is not supported yet")
         raise typer.Exit(code=1)
@@ -21,16 +27,23 @@ def run(urls: list[str], proxy: str | None) -> None:
 
 
 async def _run(urls: list[str]) -> None:
+    """Fetch and print status for all given node URLs."""
     result = {}
     for url in urls:
         result[url] = (await _node_status(url)).model_dump()
 
-    mm_print.json(result)
+    print_json(result)
 
 
 async def _node_status(url: str) -> NodeStatus:
+    """Fetch status from a single node."""
     client = FullNodeClient(node_url=url)
 
+    try:
+        spec_version: str = await client.spec_version()
+    except Exception as e:
+        spec_version = str(e)
+
     try:
         block_number: int | str = await client.get_block_number()
     except Exception as e:
@@ -46,4 +59,4 @@ async def _node_status(url: str) -> NodeStatus:
     except Exception as e:
         syncing_status = str(e)
 
-    return NodeStatus(block_number=block_number, chain_id=chain_id, syncing_status=syncing_status)
+    return NodeStatus(spec_version=spec_version, block_number=block_number, chain_id=chain_id, syncing_status=syncing_status)

{mm_strk-0.4.2 → mm_strk-0.5.0}/src/mm_strk/domain.py

@@ -1,9 +1,12 @@
+"""Starknet domain resolution via starknet.id API."""
+
 from mm_http import http_request
 from mm_result import Result
 from mm_std import str_contains_any
 
 
 async def address_to_domain(address: str, timeout: float = 5.0, proxy: str | None = None) -> Result[str | None]:
+    """Resolve a Starknet address to its .stark domain name."""
     url = "https://api.starknet.id/addr_to_domain"
     res = await http_request(url, params={"addr": address}, proxy=proxy, timeout=timeout)
     if (
@@ -14,7 +17,7 @@ async def address_to_domain(address: str, timeout: float = 5.0, proxy: str | Non
         return res.to_result_ok(None)
     if res.is_err():
         return res.to_result_err()
-    domain = res.parse_json_body("domain")
-    if domain:
-        return res.to_result_ok(domain)
+    domain_res = res.json_body("domain")
+    if domain_res.is_ok():
+        return res.to_result_ok(domain_res.unwrap())
     return res.to_result_err("unknown_response")

mm_strk-0.5.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for mm-strk."""

{mm_strk-0.4.2 → mm_strk-0.5.0}/tests/conftest.py

@@ -1,3 +1,5 @@
+"""Shared test fixtures."""
+
 import os
 
 import pytest
@@ -10,16 +12,19 @@ MAINNET_URL = os.getenv("MAINNET_URL")
 
 @pytest.fixture
 def anyio_backend() -> str:
+    """Use asyncio as the async backend."""
     return "asyncio"
 
 
 @pytest.fixture
 def zklend_market_address() -> str:
+    """Return the zkLend market contract address."""
     return "0x04c0a5193d58f74fbace4b74dcf65481e734ed1714121bdc571da345540efa05"
 
 
 @pytest.fixture
 def mainnet_rpc_url() -> str:
+    """Return the mainnet RPC URL from environment."""
     if not MAINNET_URL:
         raise ValueError("MAINNET_URL environment variable is not set.")
     return MAINNET_URL

{mm_strk-0.4.2 → mm_strk-0.5.0}/tests/test_account.py

@@ -1,9 +1,12 @@
+"""Tests for address validation."""
+
 from starknet_py.hash.address import get_checksum_address
 
 from mm_strk.account import is_address
 
 
 def test_valid_addresses():
+    """Test that valid Starknet addresses are accepted."""
     # Compact lower-case and mixed-case hex strings
     assert is_address("0x1") is True
     assert is_address("0x123abc") is True
@@ -17,6 +20,7 @@ def test_valid_addresses():
 
 
 def test_invalid_addresses():
+    """Test that invalid Starknet addresses are rejected."""
     # Missing prefix or empty
     assert is_address("123abc") is False
     assert is_address("0x") is False

{mm_strk-0.4.2 → mm_strk-0.5.0}/tests/test_balance.py

@@ -1,7 +1,10 @@
+"""Tests for token balance querying."""
+
 from mm_strk import balance
 
 
 async def test_get_balance(mainnet_rpc_url):
+    """Test fetching ETH and STRK balances for a known address."""
     address = "0x076601136372fcdbbd914eea797082f7504f828e122288ad45748b0c8b0c9696"  # Bybit: Hot Wallet
     assert (await balance.get_balance(mainnet_rpc_url, address, balance.ETH_ADDRESS_MAINNET)).unwrap() > 1
     assert (await balance.get_balance(mainnet_rpc_url, address, balance.STRK_ADDRESS_MAINNET)).unwrap() > 1

{mm_strk-0.4.2 → mm_strk-0.5.0}/tests/test_domain.py

@@ -1,13 +1,17 @@
+"""Tests for Starknet domain resolution."""
+
 from mm_strk import domain
 
 
 async def test_address_to_domain_exist():
+    """Test resolving an address that has a .stark domain."""
     res = await domain.address_to_domain("0x0060b56b67e1b4dd1909376496b0e867f165f31c5eac7902d9ff48112f16ef9b")
     assert res.is_ok()
     assert res.unwrap() == "abc.stark"
 
 
 async def test_address_to_domain_async_not_exist():
+    """Test resolving an address that has no .stark domain."""
     res = await domain.address_to_domain("0x0060b56b67e1b4dd1909376496b0e867f165f31c5eac7902d9ff48112f16ef9a")  # not existed
     assert res.is_ok()
     assert res.unwrap() is None