#!/usr/bin/env python3 """ Bitcoin Dust Limit Calculator Technical implementation for dust threshold analysis across Bitcoin versions """ import json from typing import Dict, List, Optional, Any, Union import math from dataclasses import dataclass from datetime import datetime @dataclass class DustThreshold: """Dust threshold configuration for different output types""" output_type: str dust_limit: int input_size: int output_size: int description: str class BitcoinDustAnalyzer: """Comprehensive Bitcoin dust limit analysis tool""" def __init__(self): self.dust_relay_fee = 3000 # Default: 3000 sat/kvB self.min_relay_tx_fee = 1000 # Default: 1000 sat/kvB # Output type configurations self.output_configs = { 'P2PKH': { 'input_size': 148, 'output_size': 34, 'description': 'Legacy Pay-to-Public-Key-Hash' }, 'P2SH': { 'input_size': 148, 'output_size': 32, 'description': 'Pay-to-Script-Hash' }, 'P2WPKH': { 'input_size': 108, 'output_size': 31, 'description': 'SegWit v0 Pay-to-Witness-Public-Key-Hash' }, 'P2WSH': { 'input_size': 108, 'output_size': 43, 'description': 'SegWit v0 Pay-to-Witness-Script-Hash' }, 'P2TR': { 'input_size': 64, 'output_size': 35, 'description': 'Taproot Pay-to-Taproot (SegWit v1)' } } def calculate_dust_threshold(self, output_type: str, fee_rate: Optional[int] = None) -> DustThreshold: """Calculate dust threshold for specific output type""" if output_type not in self.output_configs: raise ValueError(f"Unsupported output type: {output_type}") config = self.output_configs[output_type] fee_rate = fee_rate or self.dust_relay_fee # Total size for spending = input_size + output_size total_size = config['input_size'] + config['output_size'] # Dust threshold = total_size * fee_rate / 1000 dust_threshold = (total_size * fee_rate) // 1000 return DustThreshold( output_type=output_type, dust_limit=dust_threshold, input_size=config['input_size'], output_size=config['output_size'], description=config['description'] ) def get_all_dust_thresholds(self, fee_rate: Optional[int] = None) -> List[DustThreshold]: """Get dust thresholds for all output types""" thresholds = [] for output_type in self.output_configs: threshold = self.calculate_dust_threshold(output_type, fee_rate) thresholds.append(threshold) return thresholds def compare_segwit_versions(self) -> Dict[str, Any]: """Compare dust limits across SegWit versions""" legacy = self.calculate_dust_threshold('P2PKH') segwit_v0 = self.calculate_dust_threshold('P2WPKH') taproot = self.calculate_dust_threshold('P2TR') # Calculate efficiency improvements legacy_limit = legacy.dust_limit segwit_v0_limit = segwit_v0.dust_limit taproot_limit = taproot.dust_limit comparison = { 'legacy': legacy, 'segwit_v0': segwit_v0, 'taproot': taproot, 'efficiency_analysis': { 'segwit_v0_improvement': { 'absolute_savings': legacy_limit - segwit_v0_limit, 'percentage_improvement': round((legacy_limit - segwit_v0_limit) / legacy_limit * 100, 1) }, 'taproot_improvement': { 'absolute_savings': legacy_limit - taproot_limit, 'percentage_improvement': round((legacy_limit - taproot_limit) / legacy_limit * 100, 1) } } } return comparison def analyze_lightning_anchors(self) -> Dict[str, Any]: """Analyze Lightning Network anchor output configuration""" anchor_value = 330 # satoshis csv_delay = 1 # block # Calculate anchor efficiency anchor_dust_threshold = self.calculate_dust_threshold('P2TR') anchor_efficiency = { 'anchor_value': anchor_value, 'dust_threshold': anchor_dust_threshold.dust_limit, 'above_dust': anchor_value > anchor_dust_threshold.dust_limit, 'csv_delay': csv_delay, 'cpfp_capability': True } # Compare with alternative strategies alternatives = { 'p2a_output': { 'min_value': 240, 'description': 'Pay-to-Anchor (Bitcoin Core v28.0)', 'weight': 41 }, 'ephemeral_dust': { 'min_value': 0, 'description': 'Ephemeral Dust (Bitcoin Core v29.0)', 'savings': anchor_value - 240 } } return { 'anchor_configuration': anchor_efficiency, 'alternatives': alternatives, 'recommendation': 'anchor_outputs' } def generate_timeline_analysis(self) -> Dict[str, Any]: """Generate historical timeline of dust limit changes""" timeline = [ { 'date': '2012-12', 'version': 'Pre-0.8', 'dust_limit': 100000, # 0.001 BTC 'description': 'Initial COIN_DUST constant', 'rationale': 'Early spam prevention' }, { 'date': '2013-05', 'version': '0.8+', 'dust_limit': 546, 'description': 'Uneconomic dust definition', 'rationale': 'Cost-based threshold (3 sat/vB × 182 bytes)' }, { 'date': '2017-03', 'version': '0.14.0', 'dust_limit': 'Variable', 'description': 'Dust calculation separated from minRelayTxFee', 'rationale': 'Independent dustRelayFee parameter' }, { 'date': '2017-08', 'version': '0.16.0+', 'dust_limit': 'Type-specific', 'description': 'SegWit v0 support (294 satoshis for P2WPKH)', 'rationale': 'Witness data discount efficiency' }, { 'date': '2021-11', 'version': '0.22.0+', 'dust_limit': 'Type-specific', 'description': 'Taproot support (330 satoshis for P2TR)', 'rationale': 'SegWit v1 key-path efficiency' } ] return {'timeline': timeline} def _serialize_segwit_comparison(self) -> Dict[str, Any]: """Serialize SegWit comparison for JSON export""" comparison = self.compare_segwit_versions() return { 'legacy': { 'output_type': comparison['legacy'].output_type, 'dust_limit': comparison['legacy'].dust_limit, 'input_size': comparison['legacy'].input_size, 'output_size': comparison['legacy'].output_size, 'description': comparison['legacy'].description }, 'segwit_v0': { 'output_type': comparison['segwit_v0'].output_type, 'dust_limit': comparison['segwit_v0'].dust_limit, 'input_size': comparison['segwit_v0'].input_size, 'output_size': comparison['segwit_v0'].output_size, 'description': comparison['segwit_v0'].description }, 'taproot': { 'output_type': comparison['taproot'].output_type, 'dust_limit': comparison['taproot'].dust_limit, 'input_size': comparison['taproot'].input_size, 'output_size': comparison['taproot'].output_size, 'description': comparison['taproot'].description }, 'efficiency_analysis': comparison['efficiency_analysis'] } def export_analysis(self) -> Dict[str, Any]: """Export complete analysis results""" return { 'timestamp': datetime.now().isoformat(), 'dust_thresholds': { 'default_fee_rate': self.dust_relay_fee, 'thresholds': [ { 'type': t.output_type, 'dust_limit': t.dust_limit, 'input_size': t.input_size, 'output_size': t.output_size, 'description': t.description } for t in self.get_all_dust_thresholds() ] }, 'segwit_comparison': self._serialize_segwit_comparison(), 'lightning_analysis': self.analyze_lightning_anchors(), 'historical_timeline': self.generate_timeline_analysis() } def main(): """Main execution function""" analyzer = BitcoinDustAnalyzer() print("=== Bitcoin Dust Limit Analysis ===\n") # Current dust thresholds print("1. Current Dust Thresholds (3000 sat/kvB):") thresholds = analyzer.get_all_dust_thresholds() for threshold in thresholds: print(f" {threshold.output_type:8}: {threshold.dust_limit:3} satoshis ({threshold.description})") # SegWit comparison print("\n2. SegWit Version Comparison:") segwit_comparison = analyzer.compare_segwit_versions() efficiency = segwit_comparison['efficiency_analysis'] print(f" Legacy (P2PKH): {segwit_comparison['legacy'].dust_limit} satoshis") print(f" SegWit v0 (P2WPKH): {segwit_comparison['segwit_v0'].dust_limit} satoshis") print(f" Taproot (P2TR): {segwit_comparison['taproot'].dust_limit} satoshis") print(f" SegWit v0 savings: {efficiency['segwit_v0_improvement']['absolute_savings']} satoshis ({efficiency['segwit_v0_improvement']['percentage_improvement']}%)") print(f" Taproot savings: {efficiency['taproot_improvement']['absolute_savings']} satoshis ({efficiency['taproot_improvement']['percentage_improvement']}%)") # Lightning analysis print("\n3. Lightning Network Anchor Analysis:") lightning = analyzer.analyze_lightning_anchors() anchor_config = lightning['anchor_configuration'] print(f" Anchor value: {anchor_config['anchor_value']} satoshis") print(f" Dust threshold: {anchor_config['dust_threshold']} satoshis") print(f" Above dust limit: {anchor_config['above_dust']}") print(f" CPFP capability: {anchor_config['cpfp_capability']}") # Export results print("\n4. Exporting analysis results...") results = analyzer.export_analysis() with open('/data/uploads/results/wish-bf7ede727ea8a06dc8ada1d42896a6c7544943004364d34f3fc36d63fe85ce67/dust_analysis_results.json', 'w') as f: json.dump(results, f, indent=2) print(" Results saved to: dust_analysis_results.json") print("\n=== Analysis Complete ===") if __name__ == "__main__": main()