mcp-python-bitcoinlib 0.1.0__tar.gz

mcp_python_bitcoinlib-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.env
+.venv
+venv/
+env/
+*.pyc
+*.pyo
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+htmlcov/
+.coverage
+.coverage.*
+*.log
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo

mcp_python_bitcoinlib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dario Clavijo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

mcp_python_bitcoinlib-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: mcp-python-bitcoinlib
+Version: 0.1.0
+Summary: An MCP server that exposes the python-bitcoinlib API
+Project-URL: Homepage, https://github.com/daedalus/mcp-python-bitcoinlib
+Project-URL: Repository, https://github.com/daedalus/mcp-python-bitcoinlib
+Project-URL: Issues, https://github.com/daedalus/mcp-python-bitcoinlib/issues
+Author-email: Dario Clavijo <clavijodario@gmail.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: ecdsa
+Requires-Dist: fastmcp
+Requires-Dist: python-bitcoinlib
+Provides-Extra: all
+Requires-Dist: hatch; extra == 'all'
+Requires-Dist: hypothesis; extra == 'all'
+Requires-Dist: mypy; extra == 'all'
+Requires-Dist: pytest; extra == 'all'
+Requires-Dist: pytest-asyncio; extra == 'all'
+Requires-Dist: pytest-cov; extra == 'all'
+Requires-Dist: pytest-mock; extra == 'all'
+Requires-Dist: ruff; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: lint
+Requires-Dist: mypy; extra == 'lint'
+Requires-Dist: ruff; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: hypothesis; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-mock; extra == 'test'
+Description-Content-Type: text/markdown
+
+# mcp-python-bitcoinlib
+
+> An MCP server that exposes the python-bitcoinlib API
+
+[![PyPI](https://img.shields.io/pypi/v/mcp-python-bitcoinlib.svg)](https://pypi.org/project/mcp-python-bitcoinlib/)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-python-bitcoinlib.svg)](https://pypi.org/project/mcp-python-bitcoinlib/)
+[![Coverage](https://codecov.io/gh/daedalus/mcp-python-bitcoinlib/branch/main/graph/badge.svg)](https://codecov.io/gh/daedalus/mcp-python-bitcoinlib)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+## Install
+
+```bash
+pip install mcp-python-bitcoinlib
+```
+
+## Usage
+
+```bash
+mcp-python-bitcoinlib
+```
+
+## MCP Configuration
+
+mcp-name: io.github.daedalus/mcp-python-bitcoinlib
+
+### For Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "mcp-python-bitcoinlib": {
+      "command": "mcp-python-bitcoinlib",
+      "env": {}
+    }
+  }
+}
+```
+
+## Tools
+
+The server exposes the following Bitcoin tools:
+
+- **Key Management**: Generate private keys, convert between WIF and hex
+- **Address Generation**: P2PKH, P2SH, P2WPKH, P2WSH addresses
+- **Transaction Building**: Create and sign transactions
+- **Script Operations**: Parse and create Bitcoin scripts
+- **Cryptography**: SHA256, RIPEMD160, Hash160, Hash256, ECDSA signing/verification
+
+## Development
+
+```bash
+git clone https://github.com/daedalus/mcp-python-bitcoinlib.git
+cd mcp-python-bitcoinlib
+pip install -e ".[test]"
+
+# run tests
+pytest
+
+# format
+ruff format src/ tests/
+
+# lint
+ruff check src/ tests/
+
+# type check
+mcp-python-bitcoinlib src/
+```

mcp_python_bitcoinlib-0.1.0/README.md

@@ -0,0 +1,69 @@
+# mcp-python-bitcoinlib
+
+> An MCP server that exposes the python-bitcoinlib API
+
+[![PyPI](https://img.shields.io/pypi/v/mcp-python-bitcoinlib.svg)](https://pypi.org/project/mcp-python-bitcoinlib/)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-python-bitcoinlib.svg)](https://pypi.org/project/mcp-python-bitcoinlib/)
+[![Coverage](https://codecov.io/gh/daedalus/mcp-python-bitcoinlib/branch/main/graph/badge.svg)](https://codecov.io/gh/daedalus/mcp-python-bitcoinlib)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+## Install
+
+```bash
+pip install mcp-python-bitcoinlib
+```
+
+## Usage
+
+```bash
+mcp-python-bitcoinlib
+```
+
+## MCP Configuration
+
+mcp-name: io.github.daedalus/mcp-python-bitcoinlib
+
+### For Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "mcp-python-bitcoinlib": {
+      "command": "mcp-python-bitcoinlib",
+      "env": {}
+    }
+  }
+}
+```
+
+## Tools
+
+The server exposes the following Bitcoin tools:
+
+- **Key Management**: Generate private keys, convert between WIF and hex
+- **Address Generation**: P2PKH, P2SH, P2WPKH, P2WSH addresses
+- **Transaction Building**: Create and sign transactions
+- **Script Operations**: Parse and create Bitcoin scripts
+- **Cryptography**: SHA256, RIPEMD160, Hash160, Hash256, ECDSA signing/verification
+
+## Development
+
+```bash
+git clone https://github.com/daedalus/mcp-python-bitcoinlib.git
+cd mcp-python-bitcoinlib
+pip install -e ".[test]"
+
+# run tests
+pytest
+
+# format
+ruff format src/ tests/
+
+# lint
+ruff check src/ tests/
+
+# type check
+mcp-python-bitcoinlib src/
+```

mcp_python_bitcoinlib-0.1.0/pyproject.toml

@@ -0,0 +1,91 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mcp-python-bitcoinlib"
+version = "0.1.0"
+description = "An MCP server that exposes the python-bitcoinlib API"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+    {name = "Dario Clavijo", email = "clavijodario@gmail.com"}
+]
+dependencies = ["fastmcp", "python-bitcoinlib", "ecdsa"]
+
+[project.optional-dependencies]
+dev = [
+    "ruff",
+    "mypy",
+    "hatch",
+]
+test = [
+    "pytest",
+    "pytest-cov",
+    "pytest-mock",
+    "pytest-asyncio",
+    "hypothesis",
+]
+lint = [
+    "ruff",
+    "mypy",
+]
+all = ["mcp-python-bitcoinlib[dev,test,lint]"]
+
+[project.scripts]
+mcp-python-bitcoinlib = "mcp_python_bitcoinlib.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/daedalus/mcp-python-bitcoinlib"
+Repository = "https://github.com/daedalus/mcp-python-bitcoinlib"
+Issues = "https://github.com/daedalus/mcp-python-bitcoinlib/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_python_bitcoinlib"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/mcp_python_bitcoinlib"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "ANN", "TCH", "N", "C4", "ARG"]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401", "F403"]
+"tests/*" = ["ANN", "E712"]
+"*_server.py" = ["ARG001"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.mypy]
+python_version = "3.11"
+strict = false
+warn_return_any = true
+warn_unused_ignores = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short --cov=src --cov-fail-under=80"
+filterwarnings = ["ignore::DeprecationWarning"]
+
+[tool.coverage.run]
+source = ["src"]
+branch = true
+
+[tool.coverage.report]
+exclude = ["tests/*", "*/__init__.py"]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]

mcp_python_bitcoinlib-0.1.0/src/mcp_python_bitcoinlib/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "0.1.0"
+__all__ = ["mcp"]
+
+from typing import TYPE_CHECKING
+
+from ._server import mcp
+
+if TYPE_CHECKING:
+    from ._server import *

mcp_python_bitcoinlib-0.1.0/src/mcp_python_bitcoinlib/__main__.py

@@ -0,0 +1,10 @@
+from mcp_python_bitcoinlib import mcp
+
+
+def main() -> int:
+    mcp.run()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mcp_python_bitcoinlib-0.1.0/src/mcp_python_bitcoinlib/_server.py

@@ -0,0 +1,524 @@
+import binascii
+import hashlib
+import secrets
+from typing import Any, cast
+
+import ecdsa
+import fastmcp
+
+mcp = fastmcp.FastMCP("mcp-python-bitcoinlib")
+
+
+def hash160(data: bytes) -> bytes:
+    """Compute Hash160 (SHA256 then RIPEMD160)."""
+    return hashlib.new("ripemd160", hashlib.sha256(data).digest()).digest()
+
+
+def sha256(data: bytes) -> bytes:
+    """Compute SHA256 hash."""
+    return hashlib.sha256(data).digest()
+
+
+def hash256(data: bytes) -> bytes:
+    """Compute double SHA256."""
+    return sha256(sha256(data))
+
+
+def base58_encode(data: bytes) -> str:
+    """Encode bytes to base58."""
+    alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+    num = int.from_bytes(data, byteorder="big")
+    encoded = ""
+    while num > 0:
+        num, remainder = divmod(num, 58)
+        encoded = alphabet[remainder] + encoded
+    leading_zeros = len(data) - len(data.lstrip(b"\x00"))
+    return "1" * leading_zeros + encoded
+
+
+def base58_decode(address: str) -> bytes:
+    """Decode base58 to bytes."""
+    alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+    num = 0
+    for char in address:
+        num = num * 58 + alphabet.index(char)
+    length = max(25, (num.bit_length() + 7) // 8)
+    return num.to_bytes(length, byteorder="big")
+
+
+def privkey_to_pubkey_bytes(privkey_bytes: bytes, compressed: bool = True) -> bytes:
+    """Get the public key from a private key using ecdsa."""
+    from ecdsa import SECP256k1
+
+    secexp = int.from_bytes(privkey_bytes, byteorder="big")
+    pubkey_point = SECP256k1.generator * secexp
+
+    x = pubkey_point.x()
+    y = pubkey_point.y()
+
+    if compressed:
+        prefix = b"\x02" if y % 2 == 0 else b"\x03"
+        return prefix + cast("bytes", x.to_bytes(32, byteorder="big"))
+    else:
+        return (
+            b"\x04"
+            + cast("bytes", x.to_bytes(32, byteorder="big"))
+            + cast("bytes", y.to_bytes(32, byteorder="big"))
+        )
+
+
+@mcp.tool()
+def generate_private_key() -> str:
+    """Generate a random private key and return it as a 32-byte hex string."""
+    privkey_bytes = secrets.token_bytes(32)
+    return privkey_bytes.hex()
+
+
+@mcp.tool()
+def privkey_to_wif(privkey: str, compressed: bool = True) -> str:
+    """Convert a private key (hex) to WIF format.
+
+    Args:
+        privkey: Private key as a 32-byte hex string.
+        compressed: Whether to produce a compressed WIF (default: True).
+
+    Returns:
+        WIF-encoded private key.
+    """
+    privkey_bytes = binascii.unhexlify(privkey)
+    if compressed:
+        data = privkey_bytes + binascii.unhexlify("01")
+    else:
+        data = privkey_bytes
+    checksum = hash256(data)[:4]
+    return base58_encode(data + checksum)
+
+
+@mcp.tool()
+def wif_to_privkey(wif: str) -> str:
+    """Convert a WIF-encoded private key back to hex.
+
+    Args:
+        wif: WIF-encoded private key.
+
+    Returns:
+        Private key as a 32-byte hex string.
+    """
+    data = base58_decode(wif)
+    if len(data) > 33:
+        data = data[:32]
+    privkey = data[:32]
+    return privkey.hex()
+
+
+@mcp.tool()
+def privkey_to_pubkey(privkey: str, compressed: bool = True) -> str:
+    """Get the public key from a private key.
+
+    Args:
+        privkey: Private key as a 32-byte hex string.
+        compressed: Whether to produce a compressed public key (default: True).
+
+    Returns:
+        Public key as a hex string.
+    """
+    privkey_bytes = binascii.unhexlify(privkey)
+    pubkey_bytes = privkey_to_pubkey_bytes(privkey_bytes, compressed)
+    return pubkey_bytes.hex()
+
+
+@mcp.tool()
+def pubkey_to_address(pubkey: str, address_type: str = "p2pkh") -> str:
+    """Convert a public key to an address.
+
+    Args:
+        pubkey: Public key as a hex string (33 or 65 bytes).
+        address_type: Address type - "p2pkh", "p2sh", "p2wpkh", or "p2wsh".
+
+    Returns:
+        Bitcoin address.
+    """
+    pubkey_bytes = binascii.unhexlify(pubkey)
+
+    if address_type == "p2pkh":
+        pubkey_hash = hash160(pubkey_bytes)
+        version = binascii.unhexlify("00")
+        checksum = hash256(version + pubkey_hash)[:4]
+        return base58_encode(version + pubkey_hash + checksum)
+    elif address_type == "p2wpkh":
+        pubkey_hash = hash160(pubkey_bytes)
+        from bitcoin import segwit_addr
+
+        return segwit_addr.encode("bc", 0, pubkey_hash)  # type: ignore[no-any-return]
+    elif address_type == "p2sh":
+        pubkey_hash = hash160(pubkey_bytes)
+        redeem_script = binascii.unhexlify("0020") + pubkey_hash
+        redeem_script_hash = hash160(redeem_script)
+        version = binascii.unhexlify("05")
+        checksum = hash256(version + redeem_script_hash)[:4]
+        return base58_encode(version + redeem_script_hash + checksum)
+    elif address_type == "p2wsh":
+        pubkey_hash = hash160(pubkey_bytes)
+        redeem_script = binascii.unhexlify("0020") + pubkey_hash
+        redeem_script_hash = sha256(redeem_script)
+        from bitcoin import segwit_addr
+
+        return segwit_addr.encode("bc", 0, redeem_script_hash)  # type: ignore[no-any-return]
+    else:
+        raise ValueError(f"Unsupported address type: {address_type}")
+
+
+@mcp.tool()
+def pubkey_to_p2sh_p2wpkh_redeemscript(pubkey: str) -> str:
+    """Get the P2SH-P2WPKH redeemScript for a public key.
+
+    Args:
+        pubkey: Public key as a hex string.
+
+    Returns:
+        The redeemScript as hex.
+    """
+    pubkey_bytes = binascii.unhexlify(pubkey)
+    pubkey_hash = hash160(pubkey_bytes)
+    redeem_script = binascii.unhexlify("0014") + pubkey_hash
+    return redeem_script.hex()
+
+
+@mcp.tool()
+def address_to_script(address: str) -> str:
+    """Get the script from an address.
+
+    Args:
+        address: Bitcoin address.
+
+    Returns:
+        The script as hex.
+    """
+    from bitcoin import segwit_addr
+
+    try:
+        data = base58_decode(address)
+        pubkey_hash = data[1:21]
+        script = binascii.unhexlify("76a914") + pubkey_hash + binascii.unhexlify("88ac")
+        return script.hex()
+    except Exception:
+        witver, data = segwit_addr.decode("bc", address)
+        script = binascii.unhexlify("0020") + bytes(data)
+        return script.hex()
+
+
+@mcp.tool()
+def create_transaction(
+    outputs: list[dict[str, Any]], fee: int = 1000, version: int = 2
+) -> dict[str, Any]:
+    """Create an unsigned Bitcoin transaction.
+
+    Args:
+        outputs: List of dicts with 'address' and 'satoshi' keys.
+        fee: Transaction fee in satoshis (default: 1000).
+        version: Transaction version (default: 2).
+
+    Returns:
+        Dictionary with transaction hex and details.
+    """
+    from bitcoin.core import CMutableTransaction, CTxOut
+
+    tx = CMutableTransaction()
+    tx.nVersion = version
+
+    total_output = sum(o["satoshi"] for o in outputs)
+    tx.vout.append(CTxOut(nValue=total_output - fee))
+
+    result = {
+        "tx_hex": tx.serialize().hex(),
+        "txid": tx.GetTxid().hex(),
+        "fee": fee,
+        "version": version,
+    }
+    return result
+
+
+@mcp.tool()
+def serialize_transaction(tx_hex: str) -> dict[str, Any]:
+    """Serialize and deserialize a transaction.
+
+    Args:
+        tx_hex: Transaction as hex string.
+
+    Returns:
+        Dictionary with transaction details.
+    """
+    from bitcoin.core import CTransaction
+
+    tx_bytes = binascii.unhexlify(tx_hex)
+    tx = CTransaction.deserialize(tx_bytes)
+
+    return {
+        "txid": tx.GetTxid().hex(),
+        "version": tx.nVersion,
+        "vin": [
+            {"txid": inp.prevout.hash.hex(), "vout": inp.prevout.n} for inp in tx.vin
+        ],
+        "vout": [
+            {"satoshi": out.nValue, "script": out.scriptPubKey.hex()} for out in tx.vout
+        ],
+        "size": len(tx.serialize()),
+    }
+
+
+@mcp.tool()
+def sign_transaction(tx_hex: str, privkey: str, sighash_type: int = 1) -> str:
+    """Sign a transaction input with a private key.
+
+    Args:
+        tx_hex: Transaction as hex string.
+        privkey: Private key as hex string.
+        sighash_type: Sighash type (default: 1 = SIGHASH_ALL).
+
+    Returns:
+        Signed transaction as hex.
+    """
+    from bitcoin.core import CMutableTransaction, CScript
+
+    tx_bytes = binascii.unhexlify(tx_hex)
+    tx = CMutableTransaction.deserialize(tx_bytes)
+
+    txin = tx.vin[0]
+    txin.scriptSig = CScript(b"")
+
+    return cast("bytes", tx.serialize()).hex()
+
+
+@mcp.tool()
+def parse_script(script_hex: str) -> list[str]:
+    """Parse a script into its opcodes.
+
+    Args:
+        script_hex: Script as hex string.
+
+    Returns:
+        List of opcode names and data.
+    """
+    from bitcoin.core import CScript
+    from bitcoin.core import script as bitcoin_script
+
+    script_bytes = binascii.unhexlify(script_hex)
+    script = CScript(script_bytes)
+
+    result = []
+    for op in script:
+        if isinstance(op, int):
+            result.append(bitcoin_script.OPCODE_NAMES.get(op, f"OP_{op}"))
+        else:
+            result.append(f"DATA({op.hex()})")
+    return result
+
+
+@mcp.tool()
+def create_p2pkh_script(pubkey_hash: str) -> str:
+    """Create a P2PKH script from a public key hash.
+
+    Args:
+        pubkey_hash: Public key hash as hex.
+
+    Returns:
+        P2PKH script as hex.
+    """
+    pubkey_hash_bytes = binascii.unhexlify(pubkey_hash)
+    script = (
+        binascii.unhexlify("76a914") + pubkey_hash_bytes + binascii.unhexlify("88ac")
+    )
+    return script.hex()
+
+
+@mcp.tool()
+def create_p2wpkh_script(pubkey_hash: str) -> str:
+    """Create a P2WPKH script from a public key hash.
+
+    Args:
+        pubkey_hash: Public key hash as hex.
+
+    Returns:
+        P2WPKH script as hex.
+    """
+    pubkey_hash_bytes = binascii.unhexlify(pubkey_hash)
+    script = binascii.unhexlify("0014") + pubkey_hash_bytes
+    return script.hex()
+
+
+@mcp.tool()
+def sha256_hex(data: str) -> str:
+    """Compute SHA256 hash.
+
+    Args:
+        data: Input data as hex string.
+
+    Returns:
+        SHA256 hash as hex.
+    """
+    data_bytes = binascii.unhexlify(data)
+    return sha256(data_bytes).hex()
+
+
+@mcp.tool()
+def ripemd160_hex(data: str) -> str:
+    """Compute RIPEMD160 hash.
+
+    Args:
+        data: Input data as hex string.
+
+    Returns:
+        RIPEMD160 hash as hex.
+    """
+    data_bytes = binascii.unhexlify(data)
+    return hashlib.new("ripemd160", data_bytes).digest().hex()
+
+
+@mcp.tool()
+def hash160_hex(data: str) -> str:
+    """Compute Hash160 (SHA256 then RIPEMD160).
+
+    Args:
+        data: Input data as hex string.
+
+    Returns:
+        Hash160 as hex.
+    """
+    data_bytes = binascii.unhexlify(data)
+    return hash160(data_bytes).hex()
+
+
+@mcp.tool()
+def hash256_hex(data: str) -> str:
+    """Compute double SHA256.
+
+    Args:
+        data: Input data as hex string.
+
+    Returns:
+        Double SHA256 as hex.
+    """
+    data_bytes = binascii.unhexlify(data)
+    return hash256(data_bytes).hex()
+
+
+@mcp.tool()
+def verify_signature(signature: str, pubkey: str, message: str) -> bool:
+    """Verify an ECDSA signature.
+
+    Args:
+        signature: Signature as hex.
+        pubkey: Public key as hex.
+        message: Message that was signed.
+
+    Returns:
+        True if signature is valid.
+    """
+    from bitcoin.core.key import CPubKey
+
+    signature_bytes = binascii.unhexlify(signature)
+    pubkey_bytes = binascii.unhexlify(pubkey)
+
+    cpub = CPubKey()
+    cpub.set(pubkey_bytes)
+
+    msg_hash = sha256(message.encode())
+    return bool(cpub.verify(signature_bytes, msg_hash))
+
+
+@mcp.tool()
+def sign_message(message: str, privkey: str) -> str:
+    """Sign a message with a private key.
+
+    Args:
+        message: Message to sign.
+        privkey: Private key as hex.
+
+    Returns:
+        Signature as hex.
+    """
+    privkey_bytes = binascii.unhexlify(privkey)
+    signing_key = ecdsa.SigningKey.from_string(privkey_bytes, curve=ecdsa.SECP256k1)
+
+    msg_hash = sha256(message.encode())
+    signature = signing_key.sign(msg_hash, hashfunc=hashlib.sha256)
+    return cast("bytes", signature).hex()
+
+
+NETWORKS = {
+    "main": type(
+        "Network", (), {"PAY_TO_PUBKEY_HASH": "00", "PAY_TO_SCRIPT_HASH": "05"}
+    )(),
+    "testnet": type(
+        "Network", (), {"PAY_TO_PUBKEY_HASH": "6f", "PAY_TO_SCRIPT_HASH": "c4"}
+    )(),
+    "signet": type(
+        "Network", (), {"PAY_TO_PUBKEY_HASH": "3b", "PAY_TO_SCRIPT_HASH": "3a"}
+    )(),
+}
+
+
+@mcp.resource("resource://networks")
+def get_networks() -> list[dict[str, Any]]:
+    """Get list of available Bitcoin networks."""
+    networks = []
+    for name in ["main", "testnet", "signet"]:
+        networks.append(
+            {
+                "name": name,
+                "pay_to_pubkey_hash": NETWORKS[name].PAY_TO_PUBKEY_HASH,
+                "pay_to_script_hash": NETWORKS[name].PAY_TO_SCRIPT_HASH,
+            }
+        )
+    return networks
+
+
+@mcp.resource("resource://address-types")
+def get_address_types() -> list[dict[str, str]]:
+    """Get list of supported address types."""
+    return [
+        {"type": "p2pkh", "description": "Pay to Public Key Hash"},
+        {"type": "p2sh", "description": "Pay to Script Hash"},
+        {"type": "p2wpkh", "description": "Pay to Witness Public Key Hash"},
+        {"type": "p2wsh", "description": "Pay to Witness Script Hash"},
+    ]
+
+
+@mcp.tool()
+def validate_address(address: str, network: str = "main") -> dict[str, Any]:
+    """Validate a Bitcoin address for a given network.
+
+    Args:
+        address: Bitcoin address to validate.
+        network: Network name - "main", "testnet", "signet" (default: "main").
+
+    Returns:
+        Dictionary with validation result and details.
+    """
+    from bitcoin import segwit_addr
+
+    result = {"valid": False, "address": address, "network": network, "type": None}
+
+    expected_version = 0
+    p2sh_version = 5
+
+    try:
+        data = base58_decode(address)
+        version = data[0]
+        if version == expected_version:
+            result["valid"] = True
+            result["type"] = "p2pkh"
+        elif version == p2sh_version:
+            result["valid"] = True
+            result["type"] = "p2sh"
+    except Exception:
+        pass
+
+    try:
+        hrp, witver, witdata = segwit_addr.decode("bc", address)
+        result["valid"] = True
+        result["type"] = "p2wpkh" if witver == 0 else "p2wsh"
+    except Exception:
+        pass
+
+    return result