mm-strk 0.4.1__tar.gz

mm_strk-0.4.1/.gitignore

@@ -0,0 +1,14 @@
+.idea
+.venv
+.env
+.coverage
+/htmlcov
+__pycache__
+*.egg-info
+pip-wheel-metadata
+.pytest_cache
+.mypy_cache
+.ruff_cache
+/dist
+/build
+/tmp

mm_strk-0.4.1/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mm-strk
+Version: 0.4.1
+Requires-Python: >=3.13
+Requires-Dist: mm-cryptocurrency~=0.4.7
+Requires-Dist: starknet-py~=0.27.0
+Requires-Dist: typer>=0.16.0

mm_strk-0.4.1/README.txt

@@ -0,0 +1,9 @@
+https://github.com/software-mansion/starknet.py
+https://starkscan.co/
+https://docs.starknet.id/devs/starknetid-api
+
+
+Problems:
+-- on macos can be:  × Failed to build `crypto-cpp-py==1.4.5`
+CMAKE_POLICY_VERSION_MINIMUM=3.5 uv pip install starknet-py
+

mm_strk-0.4.1/dict.dic

@@ -0,0 +1,5 @@
+ndigits
+usdc
+strk
+starknet
+

mm_strk-0.4.1/justfile

@@ -0,0 +1,35 @@
+set dotenv-load
+version := `uv run python -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])'`
+
+
+clean:
+    rm -rf .pytest_cache .mypy_cache .ruff_cache .coverage dist build src/*.egg-info
+
+build: clean lint audit test
+    uv build
+
+format:
+    uv run ruff check --select I --fix src tests
+    uv run ruff format src tests
+
+test:
+    uv run pytest -n auto tests
+
+lint: format
+    uv run ruff check src tests
+    uv run mypy src
+
+audit:
+    uv export --no-dev --all-extras --format requirements-txt --no-emit-project > requirements.txt
+    uv run pip-audit -r requirements.txt --disable-pip --ignore-vuln GHSA-wj6h-64fc-37mp
+    rm requirements.txt
+    uv run bandit --silent --recursive --configfile "pyproject.toml" src
+
+publish: build
+    git diff-index --quiet HEAD
+    uvx twine upload dist/**
+    git tag -a 'v{{version}}' -m 'v{{version}}'
+    git push origin v{{version}}
+
+sync:
+    uv sync

mm_strk-0.4.1/pyproject.toml

@@ -0,0 +1,83 @@
+[project]
+name = "mm-strk"
+version = "0.4.1"
+description = ""
+requires-python = ">=3.13"
+dependencies = [
+    "mm-cryptocurrency~=0.4.7",
+    "starknet-py~=0.27.0",
+    "typer>=0.16.0",
+]
+[project.scripts]
+mm-strk = "mm_strk.cli.cli:app"
+
+
+[build-system]
+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",
+]
+override-dependencies = ["pywin32 ; sys_platform == 'win32'"]
+
+
+[tool.mypy]
+python_version = "3.13"
+warn_no_return = false
+strict = true
+exclude = ["^tests/", "^tmp/"]
+
+[tool.ruff]
+line-length = 130
+target-version = "py313"
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "TC",       # flake8-type-checking, TYPE_CHECKING is dangerous, for example it doesn't work with pydantic
+    "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
+    "PLR0913",  # pylint: too-many-arguments
+    "PLR2004",  # pylint: magic-value-comparison
+    "PLC0414",  # pylint: useless-import-alias
+    "FBT",      # flake8-boolean-trap
+    "EM",       # flake8-errmsg
+    "TRY003",   # tryceratops: raise-vanilla-args
+    "C901",     # mccabe: complex-structure,
+    "BLE001",   # flake8-blind-except
+    "S311",     # bandit: suspicious-non-cryptographic-random-usage
+    "TD002",    # flake8-todos: missing-todo-author
+    "TD003",    # flake8-todos: missing-todo-link
+    "RET503",   # flake8-return: implicit-return
+    "COM812",   # it's used in ruff formatter
+    "ASYNC109", # flake8-async: async-function-with-timeout
+]
+[tool.ruff.lint.pep8-naming]
+classmethod-decorators = ["field_validator"]
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = ["ANN", "S"]
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.bandit]
+exclude_dirs = ["tests"]
+skips = ["B311"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

mm_strk-0.4.1/src/mm_strk/account.py

@@ -0,0 +1,43 @@
+import re
+
+# Maximum allowable value for a StarkNet address (251 bits)
+MAX_STARKNET_ADDRESS = 2**251
+
+
+def is_address(address: str) -> bool:
+    """
+    Validates 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).
+    """
+    # Type and prefix
+    if not isinstance(address, str) or not address.startswith("0x"):
+        return False
+
+    hex_part = address[2:]
+    # Length and hex
+    if len(hex_part) < 1 or len(hex_part) > 64:
+        return False
+    if not re.fullmatch(r"[0-9a-fA-F]+", hex_part):
+        return False
+
+    # Convert to integer and range check
+    try:
+        value = int(hex_part, 16)
+    except ValueError:
+        return False
+    if value >= MAX_STARKNET_ADDRESS:
+        return False
+
+    # Full padded 64-char form
+    if len(hex_part) == 64:
+        return True
+
+    # Minimal form (no leading zeros)
+    canonical = hex(value)[2:]
+    return hex_part.lower() == canonical

mm_strk-0.4.1/src/mm_strk/balance.py

@@ -0,0 +1,36 @@
+import aiohttp
+from aiohttp_socks import ProxyConnector
+from mm_result import Result
+from starknet_py.net.account.account import Account
+from starknet_py.net.full_node_client import FullNodeClient
+from starknet_py.net.models.chains import StarknetChainId
+from starknet_py.net.signer.key_pair import KeyPair
+
+ETH_ADDRESS_MAINNET = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7"
+ETH_DECIMALS = 18
+DAI_ADDRESS_MAINNET = "0x00da114221cb83fa859dbdb4c44beeaa0bb37c7537ad5ae66fe5e0efd20e6eb3"
+DAI_DECIMALS = 18
+USDC_ADDRESS_MAINNET = "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8"
+USDC_DECIMALS = 6
+USDT_ADDRESS_MAINNET = "0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8"
+USDT_DECIMALS = 6
+STRK_ADDRESS_MAINNET = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d"
+STRK_DECIMALS = 18
+
+
+async def get_balance(rpc_url: str, address: str, token: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
+    try:
+        timeout_config = aiohttp.ClientTimeout(total=timeout)
+        connector = ProxyConnector.from_url(proxy) if proxy else None
+        async with aiohttp.ClientSession(connector=connector, timeout=timeout_config) as session:
+            client = FullNodeClient(node_url=rpc_url, session=session)
+            account = Account(
+                address=address,
+                client=client,
+                chain=StarknetChainId.MAINNET,
+                key_pair=KeyPair(private_key=654, public_key=321),
+            )
+            balance = await account.get_balance(token_address=token)
+            return Result.ok(balance)
+    except Exception as e:
+        return Result.err(e)

mm_strk-0.4.1/src/mm_strk/cli/cli.py

@@ -0,0 +1,27 @@
+from typing import Annotated
+
+import mm_print
+import typer
+
+from mm_strk.cli import cli_utils, commands
+
+app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        mm_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
+
+
+@app.command(name="node", help="Checks RPC URLs for availability and status")
+def node_command(
+    urls: Annotated[list[str], typer.Argument()],
+    proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
+) -> None:
+    commands.node.run(urls, proxy)

mm_strk-0.4.1/src/mm_strk/cli/cli_utils.py

@@ -0,0 +1,5 @@
+import importlib.metadata
+
+
+def get_version() -> str:
+    return importlib.metadata.version("mm-strk")

mm_strk-0.4.1/src/mm_strk/cli/commands/__init__.py

@@ -0,0 +1,3 @@
+from . import node
+
+__all__ = ["node"]

mm_strk-0.4.1/src/mm_strk/cli/commands/node.py

@@ -0,0 +1,49 @@
+import asyncio
+
+import mm_print
+import typer
+from pydantic import BaseModel
+from starknet_py.net.client_models import SyncStatus
+from starknet_py.net.full_node_client import FullNodeClient
+
+
+class NodeStatus(BaseModel):
+    block_number: int | str
+    chain_id: int | str
+    syncing_status: bool | SyncStatus | str
+
+
+def run(urls: list[str], proxy: str | None) -> None:
+    if proxy:
+        typer.echo("proxy is not supported yet")
+        raise typer.Exit(code=1)
+    asyncio.run(_run(urls))
+
+
+async def _run(urls: list[str]) -> None:
+    result = {}
+    for url in urls:
+        result[url] = (await _node_status(url)).model_dump()
+
+    mm_print.json(result)
+
+
+async def _node_status(url: str) -> NodeStatus:
+    client = FullNodeClient(node_url=url)
+
+    try:
+        block_number: int | str = await client.get_block_number()
+    except Exception as e:
+        block_number = str(e)
+
+    try:
+        chain_id: int | str = int(await client.get_chain_id(), 16)
+    except Exception as e:
+        chain_id = str(e)
+
+    try:
+        syncing_status: bool | SyncStatus | str = await client.get_syncing_status()
+    except Exception as e:
+        syncing_status = str(e)
+
+    return NodeStatus(block_number=block_number, chain_id=chain_id, syncing_status=syncing_status)

mm_strk-0.4.1/src/mm_strk/domain.py

@@ -0,0 +1,20 @@
+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]:
+    url = "https://api.starknet.id/addr_to_domain"
+    res = await http_request(url, params={"addr": address}, proxy=proxy, timeout=timeout)
+    if (
+        res.status_code == 400
+        and res.body is not None
+        and str_contains_any(res.body.lower(), ["no data found", "no domain found"])
+    ):
+        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)
+    return res.to_result_err("unknown_response")

mm_strk-0.4.1/tests/conftest.py

@@ -0,0 +1,25 @@
+import os
+
+import pytest
+from dotenv import load_dotenv
+
+load_dotenv()
+
+MAINNET_URL = os.getenv("MAINNET_URL")
+
+
+@pytest.fixture
+def anyio_backend() -> str:
+    return "asyncio"
+
+
+@pytest.fixture
+def zklend_market_address() -> str:
+    return "0x04c0a5193d58f74fbace4b74dcf65481e734ed1714121bdc571da345540efa05"
+
+
+@pytest.fixture
+def mainnet_rpc_url() -> str:
+    if not MAINNET_URL:
+        raise ValueError("MAINNET_URL environment variable is not set.")
+    return MAINNET_URL

mm_strk-0.4.1/tests/test_account.py

@@ -0,0 +1,33 @@
+from starknet_py.hash.address import get_checksum_address
+
+from mm_strk.account import is_address
+
+
+def test_valid_addresses():
+    # Compact lower-case and mixed-case hex strings
+    assert is_address("0x1") is True
+    assert is_address("0x123abc") is True
+    assert is_address("0xabCdEf") is True
+    assert is_address("0x0701234567890123456789012345678901234567890123456789012345678901") is True
+
+    # Already checksummed address
+    raw = "0xdeadbeef"
+    checksummed = get_checksum_address(raw)
+    assert is_address(checksummed) is True
+
+
+def test_invalid_addresses():
+    # Missing prefix or empty
+    assert is_address("123abc") is False
+    assert is_address("0x") is False
+    assert is_address("") is False
+
+    # Non-hex characters
+    assert is_address("0x12G45") is False
+
+    # Wrong type
+    assert is_address(None) is False
+
+    # Too many leading zeroes (invalid compact form)
+    # e.g., 0x0123 should canonicalise to 0x123
+    assert is_address("0x0123") is False

mm_strk-0.4.1/tests/test_balance.py

@@ -0,0 +1,7 @@
+from mm_strk import balance
+
+
+async def test_get_balance(mainnet_rpc_url):
+    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.1/tests/test_domain.py

@@ -0,0 +1,13 @@
+from mm_strk import domain
+
+
+async def test_address_to_domain_exist():
+    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():
+    res = await domain.address_to_domain("0x0060b56b67e1b4dd1909376496b0e867f165f31c5eac7902d9ff48112f16ef9a")  # not existed
+    assert res.is_ok()
+    assert res.unwrap() is None