btcaaron 0.1.1__tar.gz

btcaaron-0.1.1/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.2
+Name: btcaaron
+Version: 0.1.1
+Summary: A Bitcoin Testnet transaction toolkit supporting Legacy, SegWit, and Taproot
+Home-page: https://x.com/aaron_recompile
+Author: Aaron Zhang
+Author-email: aaron.recompile@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: bitcoin-utils>=0.7.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+
+# btcaaron
+
+A simple Bitcoin Testnet toolkit for developers.  
+Easily generate addresses, scan UTXOs, build and broadcast transactions — with full support for Legacy, SegWit, and Taproot.
+
+---
+
+## 🔧 Features
+
+- ✅ Generate Legacy / SegWit / Taproot addresses from WIF
+- 🔍 Scan UTXOs and check balance via public APIs
+- 🧠 Build & sign transactions (manual or quick mode)
+- 🚀 Broadcast to Blockstream or Mempool endpoints
+- 🧪 Simple test suite for local debugging
+
+---
+
+## 📦 Installation
+
+```bash
+pip install btcaaron
+
+Or install from source:
+
+git clone https://github.com/aaron-recompile/btcaaron.git
+cd btcaaron
+pip install .
+
+
+⸻
+
+🚀 Quick Start
+
+from btcaaron import WIFKey, quick_transfer
+
+# Your testnet WIF private key
+wif = ""
+
+# Generate addresses
+key = WIFKey(wif)
+print("Taproot:", key.get_taproot().address)
+
+# Check balance
+balance = key.get_taproot().get_balance()
+print("Balance:", balance, "sats")
+
+# Quick transfer
+if balance > 1000:
+    txid = quick_transfer(wif, "taproot", "tb1q...", amount=500, fee=300)
+    print("Broadcasted:", txid)
+
+
+⸻
+
+📁 Project Structure
+
+btcaaron/
+├── btcaaron.py          # Main library
+├── test.py              # Example-based test runner
+├── README.md            # This file
+├── setup.py             # Install and packaging
+├── LICENSE              # MIT License
+
+
+⸻
+
+👨‍💻 Author
+
+Aaron Zhang
+https://x.com/aaron_recompile
+
+⸻
+
+📄 License
+
+MIT License - Free for commercial and personal use.
+

btcaaron-0.1.1/README.md

@@ -0,0 +1,79 @@
+
+
+# btcaaron
+
+A simple Bitcoin Testnet toolkit for developers.  
+Easily generate addresses, scan UTXOs, build and broadcast transactions — with full support for Legacy, SegWit, and Taproot.
+
+---
+
+## 🔧 Features
+
+- ✅ Generate Legacy / SegWit / Taproot addresses from WIF
+- 🔍 Scan UTXOs and check balance via public APIs
+- 🧠 Build & sign transactions (manual or quick mode)
+- 🚀 Broadcast to Blockstream or Mempool endpoints
+- 🧪 Simple test suite for local debugging
+
+---
+
+## 📦 Installation
+
+```bash
+pip install btcaaron
+
+Or install from source:
+
+git clone https://github.com/aaron-recompile/btcaaron.git
+cd btcaaron
+pip install .
+
+
+⸻
+
+🚀 Quick Start
+
+from btcaaron import WIFKey, quick_transfer
+
+# Your testnet WIF private key
+wif = ""
+
+# Generate addresses
+key = WIFKey(wif)
+print("Taproot:", key.get_taproot().address)
+
+# Check balance
+balance = key.get_taproot().get_balance()
+print("Balance:", balance, "sats")
+
+# Quick transfer
+if balance > 1000:
+    txid = quick_transfer(wif, "taproot", "tb1q...", amount=500, fee=300)
+    print("Broadcasted:", txid)
+
+
+⸻
+
+📁 Project Structure
+
+btcaaron/
+├── btcaaron.py          # Main library
+├── test.py              # Example-based test runner
+├── README.md            # This file
+├── setup.py             # Install and packaging
+├── LICENSE              # MIT License
+
+
+⸻
+
+👨‍💻 Author
+
+Aaron Zhang
+https://x.com/aaron_recompile
+
+⸻
+
+📄 License
+
+MIT License - Free for commercial and personal use.
+

btcaaron-0.1.1/btcaaron/__init__.py

@@ -0,0 +1,9 @@
+from .btcaaron import WIFKey, wif_to_addresses, quick_transfer
+
+__all__ = [
+    "WIFKey",
+    "wif_to_addresses",
+    "quick_transfer"
+]
+
+__version__ = "0.1.1"

btcaaron-0.1.1/btcaaron/btcaaron.py

@@ -0,0 +1,484 @@
+"""
+btcaaron - Lightweight Bitcoin Testnet Toolkit
+
+A simple, clean toolkit for Bitcoin testnet operations including address generation,
+UTXO querying, transaction creation, signing, and broadcasting.
+
+Author: Aaron Zhang (https://x.com/aaron_recompile)
+Version: 0.1.1
+License: MIT
+"""
+
+from typing import List, Dict, Optional
+import requests
+import concurrent.futures
+from bitcoinutils.setup import setup
+from bitcoinutils.keys import PrivateKey, P2pkhAddress, P2wpkhAddress, P2trAddress
+from bitcoinutils.transactions import Transaction, TxInput, TxOutput, TxWitnessInput
+from bitcoinutils.script import Script
+
+# Initialize testnet environment
+setup('testnet')
+
+# Network configuration
+TIMEOUT = 5
+MAX_WORKERS = 2
+DEFAULT_FEE = 300
+DUST_LIMIT = 546
+
+
+class WIFKey:
+    """
+    WIF Private Key Manager
+    
+    Generate different types of Bitcoin addresses from a WIF private key
+    """
+    
+    def __init__(self, wif_str: str):
+        """
+        Initialize WIF private key
+        
+        Args:
+            wif_str: WIF format private key string
+            
+        Raises:
+            ValueError: When WIF format is invalid
+        """
+        try:
+            self.wif = wif_str
+            self.private_key = PrivateKey(wif_str)
+            self.public_key = self.private_key.get_public_key()
+        except Exception as e:
+            raise ValueError(f"Invalid WIF private key: {str(e)}")
+    
+    def get_legacy(self) -> 'BTCAddress':
+        """Get Legacy address object (P2PKH)"""
+        address = self.public_key.get_address().to_string()
+        return BTCAddress(self.wif, address, "legacy", self.private_key, self.public_key)
+    
+    def get_segwit(self) -> 'BTCAddress':
+        """Get SegWit address object (P2WPKH)"""
+        address = self.public_key.get_segwit_address().to_string()
+        return BTCAddress(self.wif, address, "segwit", self.private_key, self.public_key)
+    
+    def get_taproot(self) -> 'BTCAddress':
+        """Get Taproot address object (P2TR)"""
+        address = self.public_key.get_taproot_address().to_string()
+        return BTCAddress(self.wif, address, "taproot", self.private_key, self.public_key)
+
+
+class BTCAddress:
+    """
+    Bitcoin Address Handler
+    
+    Handles specific address type operations (UTXO queries, transfers, etc.)
+    """
+    
+    def __init__(self, wif: str, address: str, addr_type: str, private_key, public_key):
+        self.wif = wif
+        self.address = address
+        self.type = addr_type
+        self.private_key = private_key
+        self.public_key = public_key
+        
+        # Create address object
+        if addr_type == "legacy":
+            self.addr_obj = P2pkhAddress(address)
+        elif addr_type == "segwit":
+            self.addr_obj = P2wpkhAddress(address)
+        elif addr_type == "taproot":
+            self.addr_obj = P2trAddress(address)
+        else:
+            raise ValueError(f"Unsupported address type: {addr_type}")
+    
+    def __str__(self) -> str:
+        return f"{self.type.upper()} Address: {self.address}"
+    
+    def scan_utxos(self, debug: bool = False) -> List[Dict]:
+        """
+        Scan all available UTXOs for this address
+        
+        Args:
+            debug: Whether to output debug information
+            
+        Returns:
+            List[Dict]: List of UTXOs
+        """
+        if debug:
+            print(f"Scanning UTXOs for {self.type} address: {self.address}")
+        
+        # API endpoints
+        apis = [
+            ("Blockstream testnet", f"https://blockstream.info/testnet/api/address/{self.address}/utxo"),
+            ("Mempool testnet", f"https://mempool.space/testnet/api/address/{self.address}/utxo"),
+        ]
+        
+        def fetch_utxos(api_info) -> Optional[List[Dict]]:
+            """Fetch UTXOs from a single API"""
+            api_name, api_url = api_info
+            try:
+                response = requests.get(api_url, timeout=TIMEOUT)
+                if response.status_code == 200:
+                    raw_utxos = response.json()
+                    if debug:
+                        print(f"  {api_name}: Found {len(raw_utxos)} UTXOs")
+                    
+                    utxos = []
+                    for utxo in raw_utxos:
+                        processed_utxo = {
+                            'txid': utxo['txid'],
+                            'vout': utxo['vout'],
+                            'amount': utxo['value'],
+                            'scriptPubKey': self.addr_obj.to_script_pub_key().to_hex(),
+                            'type': self.type.upper()
+                        }
+                        utxos.append(processed_utxo)
+                        
+                        if debug:
+                            print(f"    - {utxo['txid'][:16]}...:{utxo['vout']} = {utxo['value']} sats")
+                    
+                    return utxos
+                else:
+                    if debug:
+                        print(f"  {api_name}: HTTP {response.status_code}")
+            except Exception as e:
+                if debug:
+                    print(f"  {api_name}: Error - {str(e)}")
+            return None
+        
+        # Try APIs sequentially (simpler than concurrent)
+        for api_name, api_url in apis:
+            result = fetch_utxos((api_name, api_url))
+            if result is not None:
+                if debug:
+                    total = sum(utxo['amount'] for utxo in result)
+                    print(f"  Success: {len(result)} UTXOs, Total: {total} sats")
+                return result
+        
+        if debug:
+            print("  All APIs failed")
+        return []
+    
+    def get_balance(self, debug: bool = False) -> int:
+        """
+        Get address balance
+        
+        Args:
+            debug: Whether to output debug information
+            
+        Returns:
+            int: Address balance in satoshis
+        """
+        if debug:
+            print(f"Checking balance for {self.type} address: {self.address}")
+            
+        utxos = self.scan_utxos(debug=debug)
+        balance = sum(utxo['amount'] for utxo in utxos)
+        
+        if debug:
+            print(f"  Balance: {balance:,} sats")
+            
+        return balance
+    
+    def send(self, to_addr: str, amount: int, fee: int = DEFAULT_FEE, debug: bool = False) -> 'BTCTransaction':
+        """
+        Create and sign a transfer transaction
+        
+        Args:
+            to_addr: Recipient address
+            amount: Transfer amount in satoshis
+            fee: Transaction fee in satoshis
+            debug: Whether to output debug information
+            
+        Returns:
+            BTCTransaction: Signed transaction object
+            
+        Raises:
+            ValueError: When insufficient balance or invalid parameters
+        """
+        if debug:
+            print(f"Creating transaction from {self.type} address:")
+            print(f"  From: {self.address}")
+            print(f"  To: {to_addr}")
+            print(f"  Amount: {amount:,} sats")
+            print(f"  Fee: {fee:,} sats")
+        
+        # Get UTXOs
+        utxos = self.scan_utxos(debug=debug)
+        if not utxos:
+            raise ValueError(f"No UTXOs available for address {self.address}")
+        
+        # Check balance
+        total_needed = amount + fee
+        total_available = sum(utxo['amount'] for utxo in utxos)
+        
+        if total_available < total_needed:
+            raise ValueError(f"Insufficient balance. Need: {total_needed:,}, Available: {total_available:,}")
+        
+        # Select UTXOs (largest first)
+        utxos.sort(key=lambda x: x['amount'], reverse=True)
+        selected_utxos = []
+        total_input = 0
+        
+        for utxo in utxos:
+            selected_utxos.append(utxo)
+            total_input += utxo['amount']
+            if total_input >= total_needed:
+                break
+        
+        if debug:
+            print(f"  Selected UTXOs:")
+            for i, utxo in enumerate(selected_utxos, 1):
+                print(f"    {i}. {utxo['txid'][:16]}...:{utxo['vout']} = {utxo['amount']:,} sats")
+            print(f"  Total input: {total_input:,} sats")
+        
+        # Create transaction inputs
+        tx_inputs = []
+        for utxo in selected_utxos:
+            tx_input = TxInput(utxo['txid'], utxo['vout'])
+            tx_inputs.append(tx_input)
+        
+        # Create transaction outputs
+        tx_outputs = []
+        
+        # 1. Output to recipient
+        to_addr_obj = self._create_address_object(to_addr)
+        tx_out = TxOutput(amount, to_addr_obj.to_script_pub_key())
+        tx_outputs.append(tx_out)
+        
+        if debug:
+            print(f"  Output 1: {amount:,} sats -> {to_addr}")
+        
+        # 2. Change output (check dust limit)
+        change_amount = total_input - amount - fee
+        if change_amount > 0:
+            if change_amount < DUST_LIMIT:
+                # Change too small, add to fee
+                if debug:
+                    print(f"  Warning: Change amount {change_amount} sats < {DUST_LIMIT} sats (dust limit)")
+                    print(f"  Adding change to fee: {fee} + {change_amount} = {fee + change_amount} sats")
+            else:
+                change_out = TxOutput(change_amount, self.addr_obj.to_script_pub_key())
+                tx_outputs.append(change_out)
+                if debug:
+                    print(f"  Change: {change_amount:,} sats -> {self.address}")
+        elif debug:
+            print(f"  No change (exact amount match)")
+        
+        # Create transaction
+        has_segwit = self.type in ['segwit', 'taproot']
+        tx = Transaction(tx_inputs, tx_outputs, has_segwit=has_segwit)
+        
+        if debug:
+            print(f"  Created {'SegWit' if has_segwit else 'Legacy'} transaction")
+        
+        # Sign transaction
+        self._sign_transaction(tx, selected_utxos, debug=debug)
+        
+        signed_hex = tx.serialize()
+        
+        if debug:
+            print(f"  Signing complete!")
+            print(f"  Transaction size: {len(signed_hex)//2} bytes")
+        
+        return BTCTransaction(signed_hex, debug=debug)
+    
+    def _create_address_object(self, address: str):
+        """Create address object from address string"""
+        if address.startswith(('1', 'm', 'n')):  # Legacy
+            return P2pkhAddress(address)
+        elif address.startswith(('bc1q', 'tb1q')):  # SegWit v0
+            return P2wpkhAddress(address)
+        elif address.startswith(('bc1p', 'tb1p')):  # Taproot
+            return P2trAddress(address)
+        else:
+            raise ValueError(f"Unsupported address format: {address}")
+    
+    def _sign_transaction(self, tx: Transaction, selected_utxos: List[Dict], debug: bool = False):
+        """Sign transaction based on address type"""
+        if debug:
+            print(f"  Signing with {self.type} method...")
+        
+        if self.type == 'legacy':
+            # P2PKH signing
+            for i, tx_input in enumerate(tx.inputs):
+                previous_locking_script = self.addr_obj.to_script_pub_key()
+                sig = self.private_key.sign_input(tx, i, previous_locking_script)
+                pk = self.private_key.get_public_key().to_hex()
+                unlocking_script = Script([sig, pk])
+                tx_input.script_sig = unlocking_script
+                
+        elif self.type == 'segwit':
+            # P2WPKH signing
+            for i, tx_input in enumerate(tx.inputs):
+                script_code = self.public_key.get_address().to_script_pub_key()
+                input_amount = selected_utxos[i]['amount']
+                sig = self.private_key.sign_segwit_input(tx, i, script_code, input_amount)
+                public_key_hex = self.private_key.get_public_key().to_hex()
+                tx_input.script_sig = Script([])
+                tx.witnesses.append(TxWitnessInput([sig, public_key_hex]))
+                
+        elif self.type == 'taproot':
+            # P2TR signing
+            input_amounts = [utxo['amount'] for utxo in selected_utxos]
+            input_scripts = [self.addr_obj.to_script_pub_key() for _ in selected_utxos]
+            
+            for i, tx_input in enumerate(tx.inputs):
+                sig = self.private_key.sign_taproot_input(tx, i, input_scripts, input_amounts)
+                tx_input.script_sig = Script([])
+                tx.witnesses.append(TxWitnessInput([sig]))
+
+
+class BTCTransaction:
+    """
+    Bitcoin Transaction Handler
+    
+    Handles signed transaction broadcasting
+    """
+    
+    def __init__(self, tx_hex: str, debug: bool = False):
+        self.tx_hex = tx_hex
+        self.debug = debug
+        self.txid = None
+    
+    def __str__(self) -> str:
+        status = f"(TxID: {self.txid})" if self.txid else "(Not broadcasted)"
+        return f"BTCTransaction {status}"
+    
+    def broadcast(self) -> Optional[str]:
+        """
+        Broadcast transaction to network
+        
+        Returns:
+            Optional[str]: Transaction ID if successful, None if failed
+        """
+        if self.debug:
+            print(f"Broadcasting transaction:")
+            print(f"  Transaction size: {len(self.tx_hex)//2} bytes")
+        
+        # Broadcast endpoints
+        broadcast_apis = [
+            ("Blockstream testnet", "https://blockstream.info/testnet/api/tx"),
+            ("Mempool testnet", "https://mempool.space/testnet/api/tx"),
+        ]
+        
+        # Try each API sequentially
+        for api_name, api_url in broadcast_apis:
+            try:
+                if self.debug:
+                    print(f"  Trying {api_name}...")
+                
+                response = requests.post(
+                    api_url,
+                    data=self.tx_hex,
+                    timeout=TIMEOUT,
+                    headers={'Content-Type': 'text/plain'}
+                )
+                
+                if response.status_code == 200:
+                    response_text = response.text.strip()
+                    # Validate response is a valid transaction ID
+                    if len(response_text) == 64 and all(c in '0123456789abcdef' for c in response_text.lower()):
+                        self.txid = response_text
+                        if self.debug:
+                            print(f"    Success: {response_text}")
+                        return response_text
+                    else:
+                        if self.debug:
+                            print(f"    Invalid response format: {response_text}")
+                else:
+                    if self.debug:
+                        print(f"    HTTP {response.status_code}: {response.text[:100]}...")
+                        
+            except Exception as e:
+                if self.debug:
+                    print(f"    Error: {e}")
+        
+        if self.debug:
+            print("  All broadcast attempts failed")
+        return None
+
+
+# Convenience functions
+def wif_to_addresses(wif: str) -> Dict[str, str]:
+    """
+    Generate all address types from WIF
+    
+    Args:
+        wif: WIF private key string
+        
+    Returns:
+        Dict[str, str]: Dictionary containing all address types
+    """
+    wif_key = WIFKey(wif)
+    return {
+        'legacy': wif_key.get_legacy().address,
+        'segwit': wif_key.get_segwit().address,
+        'taproot': wif_key.get_taproot().address
+    }
+
+
+def quick_transfer(wif: str, from_type: str, to_addr: str, amount: int, 
+                  fee: int = DEFAULT_FEE, debug: bool = False) -> Optional[str]:
+    """
+    Quick transfer using specified address type
+    
+    Args:
+        wif: WIF private key
+        from_type: Sender address type ('legacy', 'segwit', 'taproot')
+        to_addr: Recipient address
+        amount: Transfer amount in satoshis
+        fee: Transaction fee in satoshis
+        debug: Whether to output debug information
+        
+    Returns:
+        Optional[str]: Transaction ID if successful, None if failed
+    """
+    try:
+        if debug:
+            print(f"Quick transfer ({from_type}):")
+        
+        # Create WIF key object
+        wif_key = WIFKey(wif)
+        
+        # Get address object by type
+        if from_type.lower() == 'legacy':
+            from_addr = wif_key.get_legacy()
+        elif from_type.lower() == 'segwit':
+            from_addr = wif_key.get_segwit()
+        elif from_type.lower() == 'taproot':
+            from_addr = wif_key.get_taproot()
+        else:
+            raise ValueError(f"Unsupported address type: {from_type}")
+        
+        # Create and sign transaction
+        tx = from_addr.send(to_addr, amount, fee, debug=debug)
+        
+        # Broadcast transaction
+        txid = tx.broadcast()
+        
+        if txid:
+            if debug:
+                print(f"  Transfer successful! TxID: {txid}")
+            return txid
+        else:
+            if debug:
+                print(f"  Transfer failed")
+            return None
+            
+    except Exception as e:
+        if debug:
+            print(f"Quick transfer failed: {str(e)}")
+        return None
+
+
+# Module information
+__version__ = "0.1.1"
+__author__ = "Aaron Zhang"
+__all__ = [
+    'WIFKey',
+    'BTCAddress', 
+    'BTCTransaction',
+    'wif_to_addresses',
+    'quick_transfer'
+]

btcaaron-0.1.1/btcaaron.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.2
+Name: btcaaron
+Version: 0.1.1
+Summary: A Bitcoin Testnet transaction toolkit supporting Legacy, SegWit, and Taproot
+Home-page: https://x.com/aaron_recompile
+Author: Aaron Zhang
+Author-email: aaron.recompile@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: bitcoin-utils>=0.7.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+
+# btcaaron
+
+A simple Bitcoin Testnet toolkit for developers.  
+Easily generate addresses, scan UTXOs, build and broadcast transactions — with full support for Legacy, SegWit, and Taproot.
+
+---
+
+## 🔧 Features
+
+- ✅ Generate Legacy / SegWit / Taproot addresses from WIF
+- 🔍 Scan UTXOs and check balance via public APIs
+- 🧠 Build & sign transactions (manual or quick mode)
+- 🚀 Broadcast to Blockstream or Mempool endpoints
+- 🧪 Simple test suite for local debugging
+
+---
+
+## 📦 Installation
+
+```bash
+pip install btcaaron
+
+Or install from source:
+
+git clone https://github.com/aaron-recompile/btcaaron.git
+cd btcaaron
+pip install .
+
+
+⸻
+
+🚀 Quick Start
+
+from btcaaron import WIFKey, quick_transfer
+
+# Your testnet WIF private key
+wif = ""
+
+# Generate addresses
+key = WIFKey(wif)
+print("Taproot:", key.get_taproot().address)
+
+# Check balance
+balance = key.get_taproot().get_balance()
+print("Balance:", balance, "sats")
+
+# Quick transfer
+if balance > 1000:
+    txid = quick_transfer(wif, "taproot", "tb1q...", amount=500, fee=300)
+    print("Broadcasted:", txid)
+
+
+⸻
+
+📁 Project Structure
+
+btcaaron/
+├── btcaaron.py          # Main library
+├── test.py              # Example-based test runner
+├── README.md            # This file
+├── setup.py             # Install and packaging
+├── LICENSE              # MIT License
+
+
+⸻
+
+👨‍💻 Author
+
+Aaron Zhang
+https://x.com/aaron_recompile
+
+⸻
+
+📄 License
+
+MIT License - Free for commercial and personal use.
+

btcaaron-0.1.1/btcaaron.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+setup.py
+btcaaron/__init__.py
+btcaaron/btcaaron.py
+btcaaron.egg-info/PKG-INFO
+btcaaron.egg-info/SOURCES.txt
+btcaaron.egg-info/dependency_links.txt
+btcaaron.egg-info/requires.txt
+btcaaron.egg-info/top_level.txt
+tests/test_btcaaron.py

btcaaron-0.1.1/btcaaron.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

btcaaron-0.1.1/btcaaron.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25.0
+bitcoin-utils>=0.7.1

btcaaron-0.1.1/btcaaron.egg-info/top_level.txt

@@ -0,0 +1 @@
+btcaaron

btcaaron-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

btcaaron-0.1.1/setup.py

@@ -0,0 +1,27 @@
+from setuptools import setup
+
+setup(
+    name="btcaaron",
+    version="0.1.1",
+    description="A Bitcoin Testnet transaction toolkit supporting Legacy, SegWit, and Taproot",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="Aaron Zhang",
+    author_email="aaron.recompile@gmail.com",   
+    url="https://x.com/aaron_recompile",
+    packages=["btcaaron"],
+    install_requires=[
+         "requests>=2.25.0",
+         "bitcoin-utils>=0.7.1"
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries",
+        "Topic :: Internet :: WWW/HTTP",
+    ],
+    python_requires=">=3.7",
+)

btcaaron-0.1.1/tests/test_btcaaron.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+btcaaron - Simple Test Examples (Refactored)
+"""
+from btcaaron import WIFKey, wif_to_addresses, quick_transfer
+
+WIF = "cPeon9fBsW2BxwJTALj3hGzh9vm8C52Uqsce7MzXGS1iFJkPF4AT"
+RECIPIENT = "tb1q2w85fm5g8kfhk9f63njplzu3yzcnluz9dgztjz"
+FEE = 300
+
+
+def get_addresses(wif):
+    key = WIFKey(wif)
+    return {
+        "Legacy": key.get_legacy(),
+        "SegWit": key.get_segwit(),
+        "Taproot": key.get_taproot(),
+    }
+
+def test_address_generation():
+    print("=" * 50)
+    print("TEST 1: Address Generation")
+    print("=" * 50)
+    try:
+        addresses = wif_to_addresses(WIF)
+        for typ, addr in addresses.items():
+            print(f"  {typ}: {addr}")
+
+        print("\nUsing WIFKey object:")
+        for typ, addr_obj in get_addresses(WIF).items():
+            print(f"  {typ:8}: {addr_obj.address}")
+
+        print("✅ Address generation test passed!")
+        return True
+    except Exception as e:
+        print(f"❌ Address generation test failed: {e}")
+        return False
+
+def test_utxo_scanning():
+    print("\n" + "=" * 50)
+    print("TEST 2: UTXO Scanning")
+    print("=" * 50)
+    try:
+        for typ, addr in get_addresses(WIF).items():
+            print(f"\n{typ} Address: {addr.address}")
+            utxos = addr.scan_utxos(debug=True)
+            balance = addr.get_balance()
+            print(f"  UTXOs: {len(utxos)} | Balance: {balance:,} sats")
+            for i, utxo in enumerate(utxos[:3], 1):
+                print(f"    {i}. {utxo['txid'][:16]}...:{utxo['vout']} = {utxo['amount']} sats")
+            if len(utxos) > 3:
+                print(f"    ... and {len(utxos) - 3} more")
+
+        print("\n✅ UTXO scanning test completed!")
+        return True
+    except Exception as e:
+        print(f"❌ UTXO scanning test failed: {e}")
+        return False
+
+def test_balance_check():
+    print("\n" + "=" * 50)
+    print("TEST 3: Balance Check")
+    print("=" * 50)
+    try:
+        balances = [(typ, addr.get_balance(), addr.address) for typ, addr in get_addresses(WIF).items()]
+        total = sum(b for _, b, _ in balances)
+
+        for typ, bal, _ in balances:
+            print(f"  {typ:8}: {bal:,} sats")
+        print(f"  Total   : {total:,} sats")
+
+        if total:
+            balances.sort(key=lambda x: x[1], reverse=True)
+            typ, bal, addr = balances[0]
+            print(f"\nHighest balance: {typ} | {bal:,} sats | {addr}")
+
+        print("\n✅ Balance check test completed!")
+        return True
+    except Exception as e:
+        print(f"❌ Balance check test failed: {e}")
+        return False
+
+def test_transfer():
+    print("\n" + "=" * 50)
+    print("TEST 4: Transfer Transaction")
+    print("=" * 50)
+    AMOUNT = 500
+    try:
+        candidates = [(t, a, a.get_balance()) for t, a in get_addresses(WIF).items() if a.get_balance() >= AMOUNT + FEE]
+        if not candidates:
+            print("❌ No address has sufficient balance.")
+            return False
+
+        from_type, from_addr, bal = sorted(candidates, key=lambda x: x[2], reverse=True)[0]
+        print(f"From: {from_addr.address} ({from_type}, {bal:,} sats)")
+        print(f"To:   {RECIPIENT} | Amount: {AMOUNT} | Fee: {FEE}")
+        if input("Proceed? (y/N): ").lower() != 'y':
+            print("Cancelled")
+            return False
+
+        txid = from_addr.send(RECIPIENT, AMOUNT, fee=FEE, debug=True).broadcast()
+        print("✅ Broadcast TXID:", txid)
+        return True
+    except Exception as e:
+        print(f"❌ Transfer test failed: {e}")
+        return False
+
+def test_quick_transfer():
+    print("\n" + "=" * 50)
+    print("TEST 5: Quick Transfer")
+    print("=" * 50)
+    AMOUNT = 400
+    FROM = "Taproot"
+    try:
+        addr = get_addresses(WIF)[FROM]
+        bal = addr.get_balance()
+        print(f"Using {FROM}: {addr.address} | {bal:,} sats")
+        if bal < AMOUNT + FEE:
+            print("❌ Insufficient balance.")
+            return False
+
+        if input("Proceed? (y/N): ").lower() != 'y':
+            print("Cancelled")
+            return False
+
+        txid = quick_transfer(WIF, FROM.lower(), RECIPIENT, AMOUNT, fee=FEE, debug=True)
+        print("✅ Quick TXID:", txid)
+        return True
+    except Exception as e:
+        print(f"❌ Quick transfer test failed: {e}")
+        return False
+
+def main():
+    tests = [
+        ("Address Generation", test_address_generation),
+        ("UTXO Scanning", test_utxo_scanning),
+        ("Balance Check", test_balance_check),
+        ("Transfer Transaction", test_transfer),
+        ("Quick Transfer", test_quick_transfer)
+    ]
+
+    print("\n📦 btcaaron Test Suite")
+    for i, (name, _) in enumerate(tests, 1):
+        print(f"{i}. {name}")
+    print("0. Run All")
+
+    try:
+        sel = input("Select (0-N): ").strip()
+        if sel == "0":
+            for name, fn in tests:
+                print(f"\n▶ {name}")
+                fn()
+        elif sel.isdigit() and 0 < int(sel) <= len(tests):
+            name, fn = tests[int(sel) - 1]
+            print(f"\n▶ {name}")
+            fn()
+        else:
+            print("❌ Invalid selection")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()