mm-btc 0.0.5__tar.gz → 0.1.0__tar.gz

mm_btc-0.1.0/.env.example

@@ -0,0 +1 @@
+PROXIES_URL=https://site.com/api/proxies

mm_btc-0.1.0/.gitignore

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

mm_btc-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.3
+Name: mm-btc
+Version: 0.1.0
+Requires-Python: >=3.12
+Requires-Dist: bitcoinlib~=0.6.15
+Requires-Dist: bit~=0.8.0
+Requires-Dist: hdwallet~=2.2.1
+Requires-Dist: mm-std~=0.1.2
+Requires-Dist: typer~=0.12.3

mm_btc-0.1.0/README.txt

@@ -0,0 +1,9 @@
+mm-btc
+
+
+Links:
+- https://en.bitcoin.it/wiki/Transaction
+- https://en.bitcoin.it/wiki/List_of_address_prefixes
+- https://github.com/bitcoin/bips/blob/master/README.mediawiki
+
+- https://github.com/Blockstream/esplora/blob/master/API.md

mm_btc-0.1.0/justfile

@@ -0,0 +1,33 @@
+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
+    uvx --from build pyproject-build --installer uv
+
+format:
+    uv run ruff check --select I --fix src tests
+    uv run ruff format src tests
+
+test:
+    uv run coverage run -m pytest -n auto tests
+
+lint: format
+    uv run ruff check src tests
+    uv run mypy src
+
+audit:
+    uv run pip-audit
+    uv run bandit -r -c "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_btc-0.0.5 → mm_btc-0.1.0}/pyproject.toml

@@ -1,37 +1,35 @@
 [project]
 name = "mm-btc"
-version = "0.0.5"
+version = "0.1.0"
 description = ""
 dependencies = [
-    "mm-std~=0.1.0",
+    "mm-std~=0.1.2",
     "hdwallet~=2.2.1",
+    "bit~=0.8.0",
+    "bitcoinlib~=0.6.15",
     "typer~=0.12.3"
 ]
 requires-python = ">=3.12"
-[project.optional-dependencies]
-dev = [
-    "build~=1.2.1",
-    "twine~=5.1.0",
-    "pytest~=8.3.2",
+[project.scripts]
+mm-btc = "mm_btc.cli.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv]
+dev-dependencies = [
+    "pytest~=8.3.3",
     "pytest-xdist~=3.6.1",
-    "pytest-httpserver~=1.0.8",
+    "pytest-httpserver~=1.1.0",
     "coverage~=7.6.0",
-    "ruff~=0.5.2",
+    "ruff~=0.6.4",
     "pip-audit~=2.7.0",
     "bandit~=1.7.7",
-    "mypy~=1.11.0",
-    "types-python-dateutil~=2.9.0",
-    "types-requests~=2.32.0.20240523",
+    "mypy~=1.11.2",
+    "types-python-dateutil~=2.9.0.20240906",
     "types-PyYAML~=6.0.12.12",
 ]
-[project.scripts]
-mm-btc = "mm_btc.cli.cli:app"
-
-
-[build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
-
 
 [tool.mypy]
 python_version = "3.12"
@@ -39,10 +37,9 @@ warn_no_return = false
 strict = true
 exclude = ["^tests/", "^tmp/"]
 [[tool.mypy.overrides]]
-module = ["hdwallet.*", "hdwallet.symbols.*", "telebot.util.*"]
+module = ["hdwallet.*", "hdwallet.symbols.*", "bit.*", "bitcoinlib.transactions.*"]
 ignore_missing_imports = true
 
-
 [tool.ruff]
 line-length = 130
 target-version = "py312"
@@ -68,7 +65,6 @@ lint.ignore = [
 quote-style = "double"
 indent-style = "space"
 
-
 [tool.bandit]
 exclude_dirs = ["tests"]
 skips = ["B311"]

mm_btc-0.1.0/src/mm_btc/blockstream.py

@@ -0,0 +1,110 @@
+from collections.abc import Sequence
+from typing import TypeAlias
+
+from mm_std import Err, HResponse, Ok, Result, hr
+from mm_std.random_ import 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"
+
+Proxy: TypeAlias = 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: int = 10, proxies: Proxy = None, attempts: int = 1):
+        self.testnet = testnet
+        self.timeout = timeout
+        self.proxies = proxies
+        self.attempts = attempts
+        self.base_url = TESTNET_BASE_URL if testnet else MAINNET_BASE_URL
+
+    def get_address(self, address: str) -> Result[Address]:
+        result: Result[Address] = Err("not started yet")
+        data = None
+        for _ in range(self.attempts):
+            try:
+                res = self._request(f"/address/{address}")
+                data = res.to_dict()
+                if res.code == 400 and (
+                    "invalid bitcoin address" in res.body.lower() or "bech32 segwit decoding error" in res.body.lower()
+                ):
+                    return Err(ERROR_INVALID_ADDRESS, data=data)
+                elif res.code == 400 and "invalid network" in res.body.lower():
+                    return Err(ERROR_INVALID_NETWORK, data=data)
+                return Ok(Address(**res.json), data=data)
+            except Exception as err:
+                result = Err(err, data=data)
+        return result
+
+    def get_confirmed_balance(self, address: str) -> Result[int]:
+        return self.get_address(address).and_then(lambda a: Ok(a.chain_stats.funded_txo_sum - a.chain_stats.spent_txo_sum))
+
+    def get_utxo(self, address: str) -> Result[list[Utxo]]:
+        result: Result[list[Utxo]] = Err("not started yet")
+        data = None
+        for _ in range(self.attempts):
+            try:
+                res = self._request(f"/address/{address}/utxo")
+                data = res.to_dict()
+                return Ok([Utxo(**out) for out in res.json], data=data)
+            except Exception as err:
+                result = Err(err, data=data)
+        return result
+
+    def get_mempool(self) -> Result[Mempool]:
+        result: Result[Mempool] = Err("not started yet")
+        data = None
+        for _ in range(self.attempts):
+            try:
+                res = self._request("/mempool")
+                data = res.to_dict()
+                return Ok(Mempool(**res.json), data=data)
+            except Exception as err:
+                result = Err(err, data=data)
+        return result
+
+    def _request(self, url: str) -> HResponse:
+        return hr(f"{self.base_url}{url}", timeout=self.timeout, proxy=random_str_choice(self.proxies))

{mm_btc-0.0.5 → mm_btc-0.1.0}/src/mm_btc/cli/cli.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import Annotated
 
 import typer
@@ -5,7 +6,7 @@ import typer.core
 from mm_std import print_plain
 
 from mm_btc.cli import cli_utils
-from mm_btc.cli.cmd import address_cmd, mnemonic_cmd
+from mm_btc.cli.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)
 
@@ -42,6 +43,24 @@ def address_command(address: str) -> None:
     address_cmd.run(address)
 
 
+@app.command("create-tx")
+def create_tx_command(config_path: Annotated[Path, typer.Argument(exists=True)]) -> None:
+    """Create a transaction"""
+    create_tx_cmd.run(config_path)
+
+
+@app.command("decode-tx")
+def decode_tx_command(tx_hex: str, testnet: Annotated[bool, typer.Option("--testnet", "-t")] = False) -> None:
+    """Decode a transaction"""
+    decode_tx_cmd.run(tx_hex, testnet)
+
+
+@app.command("utxo")
+def utxo_command(address: str) -> None:
+    """Get UTXOs from Blockstream API"""
+    utxo_cmd.run(address)
+
+
 def version_callback(value: bool) -> None:
     if value:
         print_plain(f"mm-btc: v{cli_utils.get_version()}")

mm_btc-0.1.0/src/mm_btc/cli/cmd/address_cmd.py

@@ -0,0 +1,10 @@
+from mm_std import print_json
+
+from mm_btc.blockstream import BlockstreamClient
+from mm_btc.wallet import is_testnet_address
+
+
+def run(address: str) -> None:
+    client = BlockstreamClient(testnet=is_testnet_address(address))
+    res = client.get_address(address)
+    print_json(res)

mm_btc-0.1.0/src/mm_btc/cli/cmd/create_tx_cmd.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+from bit import PrivateKey, PrivateKeyTestnet
+from mm_std import BaseConfig, print_console
+
+from mm_btc.wallet import is_testnet_address
+
+
+class Config(BaseConfig):
+    class Output(BaseConfig):
+        address: str
+        amount: int
+
+    from_address: str
+    private: str
+    outputs: list[Output]
+
+
+def run(config_path: Path) -> None:
+    config = Config.read_config(config_path)
+    testnet = is_testnet_address(config.from_address)
+    key = PrivateKeyTestnet(config.private) if testnet else PrivateKey(config.private)
+
+    outputs = [(o.address, o.amount, "satoshi") for o in config.outputs]
+
+    tx = key.create_transaction(outputs)
+    print_console(tx)

mm_btc-0.1.0/src/mm_btc/cli/cmd/decode_tx_cmd.py

@@ -0,0 +1,8 @@
+from mm_std import print_json
+
+from mm_btc.tx import decode_tx
+
+
+def run(tx_hex: str, testnet: bool = False) -> None:
+    res = decode_tx(tx_hex, testnet)
+    print_json(res)

mm_btc-0.1.0/src/mm_btc/cli/cmd/utxo_cmd.py

@@ -0,0 +1,11 @@
+from mm_std import print_json
+
+from mm_btc.blockstream import BlockstreamClient
+from mm_btc.wallet import is_testnet_address
+
+
+def run(address: str) -> None:
+    client = BlockstreamClient(testnet=is_testnet_address(address))
+    res = client.get_utxo(address)
+
+    print_json(res.ok_or_err())

mm_btc-0.1.0/src/mm_btc/tx.py

@@ -0,0 +1,5 @@
+from bitcoinlib.transactions import Transaction
+
+
+def decode_tx(tx_hex: str, testnet: bool = False) -> dict[str, object]:
+    return Transaction.parse(tx_hex, network="testnet" if testnet else "mainnet").as_dict()  # type: ignore[no-any-return]

mm_btc-0.1.0/tests/cli/cmd/test_mnemonic_cmd.py

@@ -0,0 +1,22 @@
+import pytest
+from mm_std import run_command
+
+from mm_btc.cli.cmd.mnemonic_cmd import get_derivation_path_prefix
+
+
+def test_get_derivation_path_prefix():
+    assert get_derivation_path_prefix("m/11'/0'/0'/0", testnet=True) == "m/11'/0'/0'/0"
+    assert get_derivation_path_prefix("bip44", False) == "m/44'/0'/0'/0"
+    assert get_derivation_path_prefix("bip44", True) == "m/44'/1'/0'/0"
+    assert get_derivation_path_prefix("bip84", False) == "m/84'/0'/0'/0"
+    assert get_derivation_path_prefix("bip84", True) == "m/84'/1'/0'/0"
+
+    with pytest.raises(ValueError):
+        get_derivation_path_prefix("bip", True)
+
+
+def test_mnemonic_cmd(mnemonic, passphrase):
+    cmd = f"mm-btc mnemonic -m '{mnemonic}' --passphrase '{passphrase}'"
+    res = run_command(cmd)
+    assert res.code == 0
+    assert "m/44'/0'/0'/0/7 1AJNF13C4xVvduE3D9pdtdDNFbL5Bm7T3u L3QF5FHUtX2a1ucGgVfrdhdvLHBSxsRQoGsv7tyY8P5Jt7UV9LZv"

mm_btc-0.1.0/tests/conftest.py

@@ -0,0 +1,34 @@
+import pytest
+from mm_std import get_dotenv, hr
+
+
+@pytest.fixture()
+def mnemonic() -> str:
+    return "hub blur cliff taste afraid master game milk nest change blame code"
+
+
+@pytest.fixture
+def passphrase() -> str:
+    return "my-secret"
+
+
+@pytest.fixture()
+def mainnet_bip44_address_0() -> str:
+    return "1Men3kiujJH7H5NXyKpFtWWtni1cTfSk48"
+
+
+@pytest.fixture
+def binance_address() -> str:
+    return "34xp4vRoCGJym3xR7yCVPFHoCNxv4Twseo"
+
+
+@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 []

mm_btc-0.1.0/tests/test_blockstream.py

@@ -0,0 +1,28 @@
+from mm_btc import blockstream
+from mm_btc.blockstream import BlockstreamClient
+
+
+def test_get_address(binance_address, proxies):
+    client = BlockstreamClient(proxies=proxies, timeout=5, attempts=5)
+
+    # non-empty address
+    res = client.get_address(binance_address)
+    assert res.unwrap().chain_stats.tx_count > 800
+
+    # empty address
+    res = client.get_address("bc1pa48c294qk7yd7sc8y0wxydc3a2frv5j83e65rvm48v3ej098s5zs8kvh6d")
+    assert res.unwrap().chain_stats.tx_count == 0
+
+    # invalid address
+    res = client.get_address("bc1pa48c294qk7yd7sc8y0wxydc3a2frv5j83e65rvm48v3ej098s5zs8kvh5d")
+    assert res.unwrap_err() == blockstream.ERROR_INVALID_ADDRESS
+
+    # invalid network
+    res = client.get_address("mqkwWDWdgXhYunfoKvQfYyydwB5vdma3cK")
+    assert res.unwrap_err() == blockstream.ERROR_INVALID_NETWORK
+
+
+def test_get_confirmed_balance(binance_address, proxies):
+    client = BlockstreamClient(proxies=proxies)
+    res = client.get_confirmed_balance(binance_address)
+    assert res.unwrap() > 0