mm-btc 0.2.1__tar.gz → 0.4.0__tar.gz

mm_btc-0.4.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: mm-btc
+Version: 0.4.0
+Requires-Python: >=3.12
+Requires-Dist: bitcoinlib~=0.7.3
+Requires-Dist: bit~=0.8.0
+Requires-Dist: hdwallet~=3.4.0
+Requires-Dist: mm-crypto-utils>=0.3.1
+Requires-Dist: mnemonic~=0.21
+Requires-Dist: typer~=0.15.2

mm_btc-0.4.0/dict.dic

@@ -0,0 +1,6 @@
+vsize
+mempool
+txid
+vout
+bech
+segwit

{mm_btc-0.2.1 → mm_btc-0.4.0}/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "mm-btc"
-version = "0.2.1"
+version = "0.4.0"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
-    "mm-std~=0.1.11",
-    "hdwallet~=3.2.3",
+    "mm-crypto-utils>=0.3.1",
+    "hdwallet~=3.4.0",
     "bit~=0.8.0",
-    "bitcoinlib~=0.7.1",
+    "bitcoinlib~=0.7.3",
     "mnemonic~=0.21",
-    "typer~=0.15.1",
+    "typer~=0.15.2",
 ]
 [project.scripts]
 mm-btc = "mm_btc.cli.cli:app"
@@ -21,14 +21,14 @@ build-backend = "hatchling.build"
 
 [tool.uv]
 dev-dependencies = [
-    "pytest~=8.3.4",
+    "pytest~=8.3.5",
     "pytest-xdist~=3.6.1",
-    "pytest-httpserver~=1.1.0",
-    "ruff~=0.9.2",
-    "pip-audit~=2.7.3",
-    "bandit~=1.8.2",
-    "mypy~=1.14.1",
-    "types-PyYAML~=6.0.12.20241230",
+    "pytest-httpserver~=1.1.3",
+    "ruff~=0.11.5",
+    "pip-audit~=2.9.0",
+    "bandit~=1.8.3",
+    "mypy~=1.15.0",
+    "pytest-asyncio>=0.26.0",
 ]
 
 
@@ -47,6 +47,7 @@ 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
@@ -68,6 +69,8 @@ ignore = [
     "RET503", # flake8-return: implicit-return
     "COM812", # it's used in ruff formatter
 ]
+[tool.ruff.lint.pep8-naming]
+classmethod-decorators = ["field_validator"]
 [tool.ruff.lint.per-file-ignores]
 "tests/*.py" = ["ANN", "S"]
 [tool.ruff.format]
@@ -78,3 +81,6 @@ indent-style = "space"
 [tool.bandit]
 exclude_dirs = ["tests"]
 skips = ["B311"]
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"

mm_btc-0.4.0/src/mm_btc/blockstream.py

@@ -0,0 +1,102 @@
+from collections.abc import Sequence
+
+from mm_std import HttpResponse, Result, http_request, random_str_choice
+from pydantic import BaseModel
+
+MAINNET_BASE_URL = "https://blockstream.info/api"
+TESTNET_BASE_URL = "https://blockstream.info/testnet/api"
+
+# ERROR_INVALID_ADDRESS = "INVALID_ADDRESS"
+# ERROR_INVALID_NETWORK = "INVALID_NETWORK"
+
+ERROR_400_BAD_REQUEST = "400 Bad Request"
+
+type Proxy = str | Sequence[str] | None
+
+
+class Mempool(BaseModel):
+    count: int
+    vsize: int
+    total_fee: int
+    fee_histogram: list[tuple[float, int]]
+
+
+class Address(BaseModel):
+    class ChainStats(BaseModel):
+        funded_txo_count: int
+        funded_txo_sum: int
+        spent_txo_count: int
+        spent_txo_sum: int
+        tx_count: int
+
+    class MempoolStats(BaseModel):
+        funded_txo_count: int
+        funded_txo_sum: int
+        spent_txo_count: int
+        spent_txo_sum: int
+        tx_count: int
+
+    chain_stats: ChainStats
+    mempool_stats: MempoolStats
+
+
+class Utxo(BaseModel):
+    class Status(BaseModel):
+        confirmed: bool
+        block_height: int
+        block_hash: str
+        block_time: int
+
+    txid: str
+    vout: int
+    status: Status
+    value: int
+
+
+class BlockstreamClient:
+    def __init__(self, testnet: bool = False, timeout: float = 5, proxies: Proxy = None, attempts: int = 1) -> None:
+        self.testnet = testnet
+        self.timeout = timeout
+        self.proxies = proxies
+        self.attempts = attempts
+        self.base_url = TESTNET_BASE_URL if testnet else MAINNET_BASE_URL
+
+    async def get_address(self, address: str) -> Result[Address]:
+        result: Result[Address] = Result.failure("not started yet")
+        for _ in range(self.attempts):
+            res = await self._request(f"/address/{address}")
+            try:
+                if res.status_code == 400:
+                    return res.to_result_failure("400 Bad Request")
+                return res.to_result_success(Address(**res.parse_json_body()))
+            except Exception as e:
+                result = res.to_result_failure(e)
+        return result
+
+    async def get_confirmed_balance(self, address: str) -> Result[int]:
+        return (await self.get_address(address)).and_then(
+            lambda a: Result.success(a.chain_stats.funded_txo_sum - a.chain_stats.spent_txo_sum)
+        )
+
+    async def get_utxo(self, address: str) -> Result[list[Utxo]]:
+        result: Result[list[Utxo]] = Result.failure("not started yet")
+        for _ in range(self.attempts):
+            res = await self._request(f"/address/{address}/utxo")
+            try:
+                return res.to_result_success([Utxo(**out) for out in res.parse_json_body()])
+            except Exception as e:
+                result = res.to_result_failure(e)
+        return result
+
+    async def get_mempool(self) -> Result[Mempool]:
+        result: Result[Mempool] = Result.failure("not started yet")
+        for _ in range(self.attempts):
+            res = await self._request("/mempool")
+            try:
+                return res.to_result_success(Mempool(**res.parse_json_body()))
+            except Exception as e:
+                result = res.to_result_failure(e)
+        return result
+
+    async def _request(self, url: str) -> HttpResponse:
+        return await http_request(f"{self.base_url}{url}", timeout=self.timeout, proxy=random_str_choice(self.proxies))

{mm_btc-0.2.1 → mm_btc-0.4.0}/src/mm_btc/cli/cli.py

@@ -1,3 +1,5 @@
+import asyncio
+import importlib.metadata
 from pathlib import Path
 from typing import Annotated
 
@@ -7,7 +9,6 @@ from mm_std import print_plain
 
 from mm_btc.wallet import AddressType
 
-from . import cli_utils
 from .cmd import address_cmd, create_tx_cmd, decode_tx_cmd, mnemonic_cmd, utxo_cmd
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
@@ -44,7 +45,7 @@ def mnemonic_command(  # nosec B107:hardcoded_password_default
 @app.command(name="a", hidden=True)
 def address_command(address: str) -> None:
     """Get address info from Blockstream API"""
-    address_cmd.run(address)
+    asyncio.run(address_cmd.run(address))
 
 
 @app.command("create-tx")
@@ -62,12 +63,12 @@ def decode_tx_command(tx_hex: str, testnet: Annotated[bool, typer.Option("--test
 @app.command("utxo")
 def utxo_command(address: str) -> None:
     """Get UTXOs from Blockstream API"""
-    utxo_cmd.run(address)
+    asyncio.run(utxo_cmd.run(address))
 
 
 def version_callback(value: bool) -> None:
     if value:
-        print_plain(f"mm-btc: v{cli_utils.get_version()}")
+        print_plain(f"mm-btc: v{importlib.metadata.version('mm-btc')}")
         raise typer.Exit
 
 

{mm_btc-0.2.1 → mm_btc-0.4.0}/src/mm_btc/cli/cmd/address_cmd.py

@@ -4,7 +4,7 @@ from mm_btc.blockstream import BlockstreamClient
 from mm_btc.wallet import is_testnet_address
 
 
-def run(address: str) -> None:
+async def run(address: str) -> None:
     client = BlockstreamClient(testnet=is_testnet_address(address))
-    res = client.get_address(address)
-    print_json(res)
+    res = await client.get_address(address)
+    print_json(res.ok_or_error())

{mm_btc-0.2.1 → mm_btc-0.4.0}/src/mm_btc/cli/cmd/create_tx_cmd.py

@@ -3,7 +3,6 @@ from pathlib import Path
 from bit import PrivateKey, PrivateKeyTestnet
 from mm_std import BaseConfig, print_console
 
-from mm_btc.cli.cli_utils import read_config
 from mm_btc.wallet import is_testnet_address
 
 
@@ -18,7 +17,7 @@ class Config(BaseConfig):
 
 
 def run(config_path: Path) -> None:
-    config = read_config(Config, config_path)
+    config = Config.read_toml_config_or_exit(config_path)
     testnet = is_testnet_address(config.from_address)
     key = PrivateKeyTestnet(config.private) if testnet else PrivateKey(config.private)
 

{mm_btc-0.2.1 → mm_btc-0.4.0}/src/mm_btc/cli/cmd/utxo_cmd.py

@@ -4,8 +4,7 @@ from mm_btc.blockstream import BlockstreamClient
 from mm_btc.wallet import is_testnet_address
 
 
-def run(address: str) -> None:
+async def run(address: str) -> None:
     client = BlockstreamClient(testnet=is_testnet_address(address))
-    res = client.get_utxo(address)
-
-    print_json(res.ok_or_err())
+    res = await client.get_utxo(address)
+    print_json(res.ok_or_error())

{mm_btc-0.2.1 → mm_btc-0.4.0}/tests/conftest.py

@@ -1,5 +1,6 @@
 import pytest
-from mm_std import get_dotenv, hr
+from mm_crypto_utils.proxy import fetch_proxies_or_fatal_sync
+from mm_std import get_dotenv
 from typer.testing import CliRunner
 
 
@@ -25,14 +26,7 @@ def binance_address() -> str:
 
 @pytest.fixture
 def proxies() -> list[str]:
-    proxies_url = get_dotenv("PROXIES_URL")
-    if proxies_url:
-        res = hr(proxies_url)
-        try:
-            return res.json["proxies"]
-        except KeyError:
-            pass
-    return []
+    return fetch_proxies_or_fatal_sync(get_dotenv("PROXIES_URL"))
 
 
 @pytest.fixture

mm_btc-0.4.0/tests/test_blockstream.py

@@ -0,0 +1,32 @@
+import pytest
+
+from mm_btc import blockstream
+from mm_btc.blockstream import BlockstreamClient
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_get_address(binance_address, proxies):
+    client = BlockstreamClient(proxies=proxies, timeout=5, attempts=5)
+
+    # non-empty address
+    res = await client.get_address(binance_address)
+    assert res.unwrap().chain_stats.tx_count > 800
+
+    # empty address
+    res = await client.get_address("bc1pa48c294qk7yd7sc8y0wxydc3a2frv5j83e65rvm48v3ej098s5zs8kvh6d")
+    assert res.unwrap().chain_stats.tx_count == 0
+
+    # invalid address
+    res = await client.get_address("bc1pa48c294qk7yd7sc8y0wxydc3a2frv5j83e65rvm48v3ej098s5zs8kvh5d")
+    assert res.unwrap_error() == blockstream.ERROR_400_BAD_REQUEST
+
+    # invalid network
+    res = await client.get_address("mqkwWDWdgXhYunfoKvQfYyydwB5vdma3cK")
+    assert res.unwrap_error() == blockstream.ERROR_400_BAD_REQUEST
+
+
+async def test_get_confirmed_balance(binance_address, proxies):
+    client = BlockstreamClient(proxies=proxies)
+    res = await client.get_confirmed_balance(binance_address)
+    assert res.unwrap() > 0