Neural Programmers </>

import requests
import threading
import logging
from bitcoin import privtopub, pubtoaddr
import secrets

# Initialize logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(name)

# Define configuration parameters
API_ENDPOINT = "https://blockstream.info/api/address/"
THREAD_COUNT = 5
#STARTING_PRIVATE_KEY = "1" * 64  # Example starting private key

def generate_private_key():
    """Generate a random private key."""
    return secrets.token_hex(32)

def bruteforce(use_proxies, proxies=None):
    """Bruteforce Bitcoin addresses."""
    try:
        while True:
            private_key = generate_private_key()  # Generate a random private key for each iteration
            address = generate_address(private_key)
            check_balance(address, private_key, proxies)
    except KeyboardInterrupt:
        logger.info("Bruteforcing stopped by user.")
    except Exception as e:
        logger.error(f"An error occurred during bruteforcing: {e}")


def generate_address(private_key):
    """Generate Bitcoin address from private key."""
    try:
        # Calculate public key from private key
        public_key = privtopub(private_key)
        
        # Calculate Bitcoin address from public key
        bitcoin_address = pubtoaddr(public_key)
        
        return bitcoin_address
    except Exception as e:
        logger.error(f"Error generating Bitcoin address from private key: {e}")
        return None

def check_balance(address, private_key, proxies=None):
    """Check balance for the given Bitcoin address."""
    try:
        response = requests.get(API_ENDPOINT + address, proxies=proxies)
        if response.status_code == 200:
            data = response.json()
            balance = data.get('final_balance', 0) / 100000000  # Convert satoshis to BTC
            logger.info(f'''
Address: {address}
Private Key: {private_key}
Balance: {balance} BTC
''')
            
            if balance > 0.00002:
                save_wallet_private_key(address, private_key, balance)
        else:
            logger.error(f"Failed to retrieve balance for address: {address}")
    except Exception as e:
        logger.error(f"Error checking balance for address: {address}, Error: {e}")

def save_wallet_private_key(address, private_key, balance):
    """Save wallet private key to wet.txt that has more than 0.00002 BTC with address and balance."""
    try:
        with open("wet.txt", "a") as file:
            file.write(f"Address: {address}, Private Key: {private_key}, Balance: {balance} BTC\n")
        logger.info("Wallet private key saved.")
    except Exception as e:
        logger.error(f"Error saving wallet private key: {e}")

def get_proxies():
    """Return proxies in the format 'http://ip:port'."""
    # Add your proxy retrieval logic here
    proxies = {
        "http": "http://user:pass@ip:port",
        "https": "https://user:pass@ip:port",
    }
    return proxies

def main():
    # Ask user if proxies should be used
    use_proxies_input = input("Do you want to use proxies? (yes/no): ").strip().lower()
    use_proxies = use_proxies_input == 'yes'

    # If using proxies, retrieve and format proxies
    proxies = get_proxies() if use_proxies else None

    # Create and start threads
    threads = []
    for _ in range(THREAD_COUNT):
        thread = threading.Thread(target=bruteforce, args=(use_proxies, get_proxies() if use_proxies else None))

        thread.start()
        threads.append(thread)

    # Wait for all threads to complete
    for thread in threads:
        thread.join()

    logger.info("Bruteforcing completed.")

if name == "main":
    main()