This is what happens when dust gets consolidated
Transaction that reveals address ownership

Inputs (UTXOs being spent):
- 0.5 BTC from address 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa (your main address)
- 0.00001 BTC from address 3Dust7f5 (dust attack address)

When you create this transaction, you just revealed
that both addresses belong to you!

from bitcoinlib.wallet import Wallet
from bitcoinlib.services.bitcoind import BitcoindClient

def check_for_dust(addresses, dust_threshold_satoshis=1000):
    """
    Check if any addresses have received dust amounts.

    Args:
        addresses: List of Bitcoin addresses to monitor
        dust_threshold_satoshis: Amount below which is considered dust

    Returns:
        List of tuples: (address, dust_amount_satoshis, txid)
    """
    client = BitcoindClient()
    dust_utxos = []

    for address in addresses:
        try:
            utxos = client.getutxos(address)
            for utxo in utxos:
                amount_sats = int(utxo['value'] * 100000000)
                if amount_sats <= dust_threshold_satoshis:
                    dust_utxos.append((
                        address,
                        amount_sats,
                        utxo['txid']
                    ))
        except Exception as e:
            print(f"Error checking {address}: {e}")

    return dust_utxos

Example usage
my_addresses = [
    'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
    'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4'
]

dust_found = check_for_dust(my_addresses)
if dust_found:
    print(f"WARNING: Dust detected!")
    for addr, amount, txid in dust_found:
        print(f"  {addr}: {amount} sats (tx: {txid})")

import requests

def check_dust_with_blockstream(address):
    """Check address for small UTXOs using Blockstream API"""
    url = f"https://blockstream.info/api/address/{address}/utxo"
    response = requests.get(url, timeout=10)

    if response.status_code != 200:
        return []

    utxos = response.json()
    dust = []

    for utxo in utxos:
        # Less than 300 sats is almost certainly dust
        if utxo['value'] < 300:
            dust.append({
                'txid': utxo['txid'],
                'vout': utxo['vout'],
                'satoshis': utxo['value']
            })

    return dust

Check for dust
result = check_dust_with_blockstream('your-address-here')
print(f"Found {len(result)} dust UTXOs")

Configure Electrum to not automatically spend small UTXOs
In electrum.conf:
dust_threshold: 5460

Explicit UTXO selection with Bitcoin Core
bitcoin-cli command to list UTXOs first
import subprocess

def list_utxos(wallet_name):
    result = subprocess.run(
        ['bitcoin-cli', '-wallet', wallet_name, 'listunspent', '0', '9999999'],
        capture_output=True, text=True
    )
    import json
    utxos = json.loads(result.stdout)

    # Filter out small UTXOs
    return [u for u in utxos if u['amount'] * 1e8 > 5460]

#!/usr/bin/env python3
bitcoin-privacy-analyzer.py

import subprocess
import json
from collections import defaultdict

class BitcoinPrivacyAnalyzer:
    """Analyze blockchain exposure and recommend mitigations"""

    def __init__(self, wallet_addresses):
        self.addresses = wallet_addresses
        self.blockchain_data = defaultdict(list)

    def check_multiple_outputs(self, tx_hash):
        """Detect common-output heuristic vulnerabilities"""
        # Check if transaction has multiple outputs
        # Multiple outputs in same transaction = potential address clustering

        result = subprocess.run(
            ['bitcoin-cli', 'getrawtransaction', tx_hash, '1'],
            capture_output=True,
            text=True
        )

        try:
            tx = json.loads(result.stdout)
            outputs = len(tx['vout'])

            if outputs > 1:
                return {
                    'vulnerability': 'multiple_outputs',
                    'risk': 'HIGH' if outputs > 3 else 'MEDIUM',
                    'count': outputs,
                    'recommendation': 'Use CoinJoin for future transactions'
                }
        except:
            pass

        return None

    def analyze_change_address(self, utxo_list):
        """Identify likely change addresses using heuristics"""
        # Change addresses often:
        # 1. Use same script type as first input
        # 2. Receive value close to input minus fee

        vulnerabilities = []

        for utxo in utxo_list:
            # Simplified change detection
            if utxo.get('script_type') == 'change_pattern':
                vulnerabilities.append({
                    'address': utxo['address'],
                    'likelihood': 'change_address',
                    'risk': 'HIGH'
                })

        return vulnerabilities

    def recommend_privacy_measures(self, risk_assessment):
        """Based on analysis, recommend privacy improvements"""
        recommendations = {
            'immediate': [],
            'short_term': [],
            'long_term': []
        }

        if any(v['vulnerability'] == 'dust_detected' for v in risk_assessment):
            recommendations['immediate'].append(
                'Do NOT spend dust UTXOs with other outputs'
            )
            recommendations['short_term'].append(
                'Use consolidation transaction with CoinJoin'
            )

        if any('change_address' in str(v) for v in risk_assessment):
            recommendations['short_term'].append(
                'Use privacy-enhanced wallet (Samourai, Wasabi) for Whirlpool'
            )

        recommendations['long_term'].append(
            'Use Lightning Network for frequent small transactions'
        )

        return recommendations

Usage
addresses = [
    'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
    'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4'
]

analyzer = BitcoinPrivacyAnalyzer(addresses)

#!/usr/bin/env python3
hardware-wallet-dust-monitor.py

import requests
import json

class HardwareWalletMonitor:
    """Monitor hardware wallet for dust attacks"""

    def __init__(self, xpub):
        self.xpub = xpub
        self.dust_threshold = 546  # Bitcoin dust limit
        self.dust_utxos = []

    def check_for_dust_on_blockchain(self):
        """Query blockchain API for dust UTXOs (privacy via Tor recommended)"""
        # Using Blockstream API as example (privacy-friendly)
        endpoint = f"https://blockstream.info/api/address/{self.xpub}/utxo"

        try:
            response = requests.get(endpoint, timeout=30)
            utxos = response.json()

            for utxo in utxos:
                if utxo['value'] < self.dust_threshold:
                    self.dust_utxos.append({
                        'txid': utxo['txid'],
                        'vout': utxo['vout'],
                        'value': utxo['value'],
                        'risk': 'HIGH - likely dust attack'
                    })

            return self.dust_utxos

        except requests.RequestException as e:
            print(f"API error: {e}")
            return []

    def generate_prevention_report(self):
        """Create report on dust handling"""
        if not self.dust_utxos:
            return {"status": "clean", "dust_count": 0}

        return {
            "status": "dust_detected",
            "dust_count": len(self.dust_utxos),
            "actions": [
                "Do not spend dust with other outputs",
                "Wait for confirmed CoinJoin round",
                "Use batched transaction after privacy mixing"
            ]
        }

Usage
monitor = HardwareWalletMonitor('xpub...')
dust = monitor.check_for_dust_on_blockchain()

if dust:
    print(f"Found {len(dust)} dust UTXOs")
    for d in dust:
        print(f"  {d['value']} sats in {d['txid']}")