mm-btc 0.3.0__tar.gz → 0.4.1__tar.gz

mm_btc-0.4.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: mm-btc
+Version: 0.4.1
+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.4
+Requires-Dist: mnemonic~=0.21
+Requires-Dist: typer~=0.15.2

{mm_btc-0.3.0 → mm_btc-0.4.1}/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "mm-btc"
-version = "0.3.0"
+version = "0.4.1"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
-    "mm-crypto-utils>=0.1.3",
-    "hdwallet~=3.2.3",
+    "mm-crypto-utils>=0.3.4",
+    "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.4",
-    "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.6",
+    "pip-audit~=2.9.0",
+    "bandit~=1.8.3",
+    "mypy~=1.15.0",
+    "pytest-asyncio>=0.26.0",
 ]
 
 
@@ -81,3 +81,7 @@ indent-style = "space"
 [tool.bandit]
 exclude_dirs = ["tests"]
 skips = ["B311"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

mm_btc-0.4.1/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.err("not started yet")
+        for _ in range(self.attempts):
+            res = await self._request(f"/address/{address}")
+            try:
+                if res.status_code == 400:
+                    return res.to_err_result("400 Bad Request")
+                return res.to_ok_result(Address(**res.parse_json_body()))
+            except Exception as e:
+                result = res.to_err_result(e)
+        return result
+
+    async def get_confirmed_balance(self, address: str) -> Result[int]:
+        return (await self.get_address(address)).and_then(
+            lambda a: Result.ok(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.err("not started yet")
+        for _ in range(self.attempts):
+            res = await self._request(f"/address/{address}/utxo")
+            try:
+                return res.to_ok_result([Utxo(**out) for out in res.parse_json_body()])
+            except Exception as e:
+                result = res.to_err_result(e)
+        return result
+
+    async def get_mempool(self) -> Result[Mempool]:
+        result: Result[Mempool] = Result.err("not started yet")
+        for _ in range(self.attempts):
+            res = await self._request("/mempool")
+            try:
+                return res.to_ok_result(Mempool(**res.parse_json_body()))
+            except Exception as e:
+                result = res.to_err_result(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.3.0 → mm_btc-0.4.1}/src/mm_btc/cli/cli.py

@@ -1,3 +1,4 @@
+import asyncio
 import importlib.metadata
 from pathlib import Path
 from typing import Annotated
@@ -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,7 +63,7 @@ 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:

{mm_btc-0.3.0 → mm_btc-0.4.1}/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.3.0 → mm_btc-0.4.1}/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.3.0 → mm_btc-0.4.1}/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.1/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