Python Blockchain Implementation: Dynamic Wallets, Multi-Process Mining, and Scalability Enhancements (Part 2)

from block import Block
from proof_of_work import proof_of_work
from transaction import Transaction
from utils import GENESIS_DATA, calculate_reward, DIFFICULTY, HALVING_INTERVAL
from wallet import Wallet
from ecdsa import SigningKey, SECP256k1
import json
import os  # For backups

class Blockchain:
    def __init__(self):
        self.difficulty = DIFFICULTY
        self.chain = [self._create_genesis_block()]
        self.pending_transactions = []

    # ... (existing _create_genesis_block, get_latest_block, mine_pending, is_valid_chain, get_balance, save_chain, load_chain)

    def add_transaction(self, txn):
        # ENHANCEMENT: Double-spend prevention
        sender_balance = self.get_balance(txn.from_addr)
        if txn.from_addr != "network" and sender_balance < txn.amount:
            raise ValueError(f"Insufficient balance: {sender_balance} < {txn.amount}")
        self.pending_transactions.append(txn)

    def add_wallet(self, wallet):
        # ENHANCEMENT: Dynamic wallet append
        all_wallets = self.load_wallets() + [wallet]
        self.save_wallets(all_wallets)

    def get_all_wallets(self):
        return self.load_wallets()

    def mine_pending(self, miner_wallet):
        # ... (existing logic)
        self.chain.append(new_block)
        self.pending_transactions = []
        if len(self.chain) % HALVING_INTERVAL == 0:
            print(f"Halving! New reward: {calculate_reward(len(self.chain))}")
        self.save_chain()
        # ENHANCEMENT: Auto-backup every 5 blocks
        if len(self.chain) % 5 == 0:
            backup_file = f'chain_backup_{len(self.chain)}.json'
            self.save_chain(backup_file)
            print(f"Backup: {backup_file}")
        print(f"Auto-saved after mining Block {new_block.index}")

    # ... (existing save/load_wallets)

from block import Block
from proof_of_work import proof_of_work
from transaction import Transaction
from utils import GENESIS_DATA, calculate_reward, DIFFICULTY, HALVING_INTERVAL
from wallet import Wallet
from ecdsa import SigningKey, SECP256k1
import json
import os  # For backups

class Blockchain:
    def __init__(self):
        self.difficulty = DIFFICULTY
        self.chain = [self._create_genesis_block()]
        self.pending_transactions = []

    # ... (existing _create_genesis_block, get_latest_block, mine_pending, is_valid_chain, get_balance, save_chain, load_chain)

    def add_transaction(self, txn):
        # ENHANCEMENT: Double-spend prevention
        sender_balance = self.get_balance(txn.from_addr)
        if txn.from_addr != "network" and sender_balance < txn.amount:
            raise ValueError(f"Insufficient balance: {sender_balance} < {txn.amount}")
        self.pending_transactions.append(txn)

    def add_wallet(self, wallet):
        # ENHANCEMENT: Dynamic wallet append
        all_wallets = self.load_wallets() + [wallet]
        self.save_wallets(all_wallets)

    def get_all_wallets(self):
        return self.load_wallets()

    def mine_pending(self, miner_wallet):
        # ... (existing logic)
        self.chain.append(new_block)
        self.pending_transactions = []
        if len(self.chain) % HALVING_INTERVAL == 0:
            print(f"Halving! New reward: {calculate_reward(len(self.chain))}")
        self.save_chain()
        # ENHANCEMENT: Auto-backup every 5 blocks
        if len(self.chain) % 5 == 0:
            backup_file = f'chain_backup_{len(self.chain)}.json'
            self.save_chain(backup_file)
            print(f"Backup: {backup_file}")
        print(f"Auto-saved after mining Block {new_block.index}")

    # ... (existing save/load_wallets)

from mnemonic import Mnemonic  # pip install mnemonic
from bip32utils import BIP32Key  # pip install bip32utils
from ecdsa import SigningKey, SECP256k1  # For key creation
from wallet import Wallet  # FIXED: Missing import for address generation
from blockchain import Blockchain  # For persistence
import sys
import hashlib
import base58


def generate_wallets(n=1):
    mnemo = Mnemonic("english")
    bc = Blockchain()
    new_wallets = []
    for i in range(n):
        # Step 1: Generate 12-word mnemonic
        mnemonic = mnemo.generate(strength=128)  # 128-bit entropy
        print(f"\nWallet {i + 1} Mnemonic (backup these words!): {mnemonic}")

        # Step 2: Derive seed from mnemonic (BIP39)
        seed = mnemo.to_seed(mnemonic)

        # Step 3: Derive master private key (BIP32)
        master_key = BIP32Key.fromEntropy(seed)
        private_key_hex = master_key.PrivateKey().hex()

        # Step 4: Create Wallet instance for address
        try:
            w = Wallet()
            w.private_key = SigningKey.from_string(bytes.fromhex(private_key_hex), curve=SECP256k1)
            w.public_key = w.private_key.get_verifying_key()
            w.address = w.generate_address()

            # Display keys
            print(f"Private Key (hex): {private_key_hex}")
            print(f"Public Key (hex): {w.public_key.to_string().hex()}")
            print(f"Address: {w.address}")

            # Secure export (warn user)
            print("WARNING: Back up mnemonic privately. Never share keys.")

            # Export private key to file (for demo; encrypt in prod)
            with open(f"private_{w.address[:8]}.key", 'w') as f:
                f.write(private_key_hex)

            print(f"Wallet {i + 1} created successfully!")
            new_wallets.append(w)
        except Exception as e:
            print(f"Key derivation error for wallet {i + 1}: {e}")
            continue  # Skip bad one

    # Persist to wallets.json (append)
    all_wallets = bc.load_wallets() + new_wallets
    bc.save_wallets(all_wallets)
    print(f"\nGenerated {len(new_wallets)} wallets (total persisted: {len(all_wallets)}).")


if __name__ == "__main__":
    n = int(sys.argv[1]) if len(sys.argv) > 1 else 5
    generate_wallets(n)

from mnemonic import Mnemonic  # pip install mnemonic
from bip32utils import BIP32Key  # pip install bip32utils
from ecdsa import SigningKey, SECP256k1  # For key creation
from wallet import Wallet  # FIXED: Missing import for address generation
from blockchain import Blockchain  # For persistence
import sys
import hashlib
import base58


def generate_wallets(n=1):
    mnemo = Mnemonic("english")
    bc = Blockchain()
    new_wallets = []
    for i in range(n):
        # Step 1: Generate 12-word mnemonic
        mnemonic = mnemo.generate(strength=128)  # 128-bit entropy
        print(f"\nWallet {i + 1} Mnemonic (backup these words!): {mnemonic}")

        # Step 2: Derive seed from mnemonic (BIP39)
        seed = mnemo.to_seed(mnemonic)

        # Step 3: Derive master private key (BIP32)
        master_key = BIP32Key.fromEntropy(seed)
        private_key_hex = master_key.PrivateKey().hex()

        # Step 4: Create Wallet instance for address
        try:
            w = Wallet()
            w.private_key = SigningKey.from_string(bytes.fromhex(private_key_hex), curve=SECP256k1)
            w.public_key = w.private_key.get_verifying_key()
            w.address = w.generate_address()

            # Display keys
            print(f"Private Key (hex): {private_key_hex}")
            print(f"Public Key (hex): {w.public_key.to_string().hex()}")
            print(f"Address: {w.address}")

            # Secure export (warn user)
            print("WARNING: Back up mnemonic privately. Never share keys.")

            # Export private key to file (for demo; encrypt in prod)
            with open(f"private_{w.address[:8]}.key", 'w') as f:
                f.write(private_key_hex)

            print(f"Wallet {i + 1} created successfully!")
            new_wallets.append(w)
        except Exception as e:
            print(f"Key derivation error for wallet {i + 1}: {e}")
            continue  # Skip bad one

    # Persist to wallets.json (append)
    all_wallets = bc.load_wallets() + new_wallets
    bc.save_wallets(all_wallets)
    print(f"\nGenerated {len(new_wallets)} wallets (total persisted: {len(all_wallets)}).")


if __name__ == "__main__":
    n = int(sys.argv[1]) if len(sys.argv) > 1 else 5
    generate_wallets(n)

import time
from blockchain import Blockchain

def run_miner(miner_address, interval=30):
    bc = Blockchain()
    bc.load_chain()
    miner_wallet = Wallet()
    miner_wallet.address = miner_address
    print(f"Miner daemon started for {miner_address}. Interval: {interval}s")
    block_count = len(bc.chain)
    while True:
        bc.mine_pending(miner_wallet)
        print(f"Mined Block {len(bc.chain)} | Balance: {bc.get_balance(miner_address)}")
        time.sleep(interval)

if __name__ == "__main__":
    address = input("Miner address: ").strip()
    run_miner(address)

import time
from blockchain import Blockchain

def run_miner(miner_address, interval=30):
    bc = Blockchain()
    bc.load_chain()
    miner_wallet = Wallet()
    miner_wallet.address = miner_address
    print(f"Miner daemon started for {miner_address}. Interval: {interval}s")
    block_count = len(bc.chain)
    while True:
        bc.mine_pending(miner_wallet)
        print(f"Mined Block {len(bc.chain)} | Balance: {bc.get_balance(miner_address)}")
        time.sleep(interval)

if __name__ == "__main__":
    address = input("Miner address: ").strip()
    run_miner(address)

# ... (existing imports and __init__)

# In while loop:
elif cmd == "txn":
    try:
        wallets = bc.get_all_wallets()
        print("Wallets:")
        for i, w in enumerate(wallets):
            print(f"{i}: {w.address} (Bal: {bc.get_balance(w.address)})")
        from_i = int(input("From index: "))
        to_i = int(input("To index: "))
        amount = float(input("Amount: "))
        new_tx = Transaction(wallets[from_i].address, wallets[to_i].address, amount)
        new_tx.sign_tx(wallets[from_i])
        bc.add_transaction(new_tx)
        print("Added to pending!")
    except (ValueError, IndexError) as e:
        print(f"Error: {e}")

elif cmd == "mined":
    wallets = bc.get_all_wallets()
    print("Wallets:")
    for i, w in enumerate(wallets):
        print(f"{i}: {w.address}")
    miner_i = int(input("Miner index: "))
    bc.mine_pending(wallets[miner_i])
    print(f"Mined! Length: {len(bc.chain)}")

# ... (existing imports and __init__)

# In while loop:
elif cmd == "txn":
    try:
        wallets = bc.get_all_wallets()
        print("Wallets:")
        for i, w in enumerate(wallets):
            print(f"{i}: {w.address} (Bal: {bc.get_balance(w.address)})")
        from_i = int(input("From index: "))
        to_i = int(input("To index: "))
        amount = float(input("Amount: "))
        new_tx = Transaction(wallets[from_i].address, wallets[to_i].address, amount)
        new_tx.sign_tx(wallets[from_i])
        bc.add_transaction(new_tx)
        print("Added to pending!")
    except (ValueError, IndexError) as e:
        print(f"Error: {e}")

elif cmd == "mined":
    wallets = bc.get_all_wallets()
    print("Wallets:")
    for i, w in enumerate(wallets):
        print(f"{i}: {w.address}")
    miner_i = int(input("Miner index: "))
    bc.mine_pending(wallets[miner_i])
    print(f"Mined! Length: {len(bc.chain)}")

from mnemonic import Mnemonic  # pip install mnemonic
from bip32utils import BIP32Key  # pip install bip32utils
from ecdsa import SigningKey, SECP256k1
from wallet import Wallet  # For address derivation
import sys
import base58
import hashlib


def restore_wallet(input_type, input_value, bc=None):
    """Restore from mnemonic or private key hex; optional balance query."""
    if input_type == "mnemonic":
        mnemo = Mnemonic("english")
        if not mnemo.check(input_value):
            raise ValueError("Invalid mnemonic—check spelling.")
        # Derive seed (BIP39)
        seed = mnemo.to_seed(input_value)
        # Derive master private key (BIP32)
        master_key = BIP32Key.fromEntropy(seed)
        private_key_hex = master_key.PrivateKey().hex()
        mnemonic = input_value
    elif input_type == "private_key":
        # Validate hex (64 chars)
        if len(input_value) != 64 or not all(c in '0123456789abcdefABCDEF' for c in input_value):
            raise ValueError("Invalid private key hex—must be 64 hex chars.")
        private_key_hex = input_value.lower()
        mnemonic = "N/A (direct private key)"
    else:
        raise ValueError("Input type must be 'mnemonic' or 'private_key'.")

    # Create restored wallet
    w = Wallet()
    w.private_key = SigningKey.from_string(bytes.fromhex(private_key_hex), curve=SECP256k1)
    w.public_key = w.private_key.get_verifying_key()
    w.address = w.generate_address()

    # Derive WIF private key (compressed, mainnet)
    wif_bytes = b'\x80' + bytes.fromhex(private_key_hex) + b'\x01'  # Compressed
    wif_private = base58.b58encode_check(wif_bytes).decode()

    # Output all info
    print("\n=== Restored Wallet Information ===")
    print(f"Mnemonic (backup words): {mnemonic}")
    print(f"Private Key (hex): {private_key_hex}")
    print(f"Private Key (WIF): {wif_private}")
    print(f"Public Key (compressed hex): {w.public_key.to_string('compressed').hex()}")
    print(f"Address: {w.address}")
    if bc:
        print(f"Current Balance: {bc.get_balance(w.address)}")
    print("=== End Restoration ===")

    return w


def print_help():
    print("Usage: python restore_wallet.py [type] [value]")
    print("Type: 'mnemonic' or 'private_key'")
    print("Value: 12-24 words for mnemonic, or 64-hex chars for private key")
    print("Example: python restore_wallet.py mnemonic 'abandon ability able ...'")
    print("Interactive: Run without args for prompts.")


if __name__ == "__main__":
    if len(sys.argv) == 2 and sys.argv[1] == "--help":
        print_help()
        sys.exit(0)

    if len(sys.argv) > 2:
        # Arg mode: sys.argv[1] = type, sys.argv[2:] = value
        input_type = sys.argv[1]
        input_value = ' '.join(sys.argv[2:])
    else:
        # Interactive
        input_type = input("Restore type (mnemonic/private_key): ").strip().lower()
        if input_type not in ['mnemonic', 'private_key']:
            print("Invalid type—use 'mnemonic' or 'private_key'.")
            print_help()
            sys.exit(1)
        input_value = input("Enter value: ").strip()

    try:
        restored = restore_wallet(input_type, input_value)
        print("Restoration successful—use address for transactions.")
    except ValueError as e:
        print(f"Error: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")

from mnemonic import Mnemonic  # pip install mnemonic
from bip32utils import BIP32Key  # pip install bip32utils
from ecdsa import SigningKey, SECP256k1
from wallet import Wallet  # For address derivation
import sys
import base58
import hashlib


def restore_wallet(input_type, input_value, bc=None):
    """Restore from mnemonic or private key hex; optional balance query."""
    if input_type == "mnemonic":
        mnemo = Mnemonic("english")
        if not mnemo.check(input_value):
            raise ValueError("Invalid mnemonic—check spelling.")
        # Derive seed (BIP39)
        seed = mnemo.to_seed(input_value)
        # Derive master private key (BIP32)
        master_key = BIP32Key.fromEntropy(seed)
        private_key_hex = master_key.PrivateKey().hex()
        mnemonic = input_value
    elif input_type == "private_key":
        # Validate hex (64 chars)
        if len(input_value) != 64 or not all(c in '0123456789abcdefABCDEF' for c in input_value):
            raise ValueError("Invalid private key hex—must be 64 hex chars.")
        private_key_hex = input_value.lower()
        mnemonic = "N/A (direct private key)"
    else:
        raise ValueError("Input type must be 'mnemonic' or 'private_key'.")

    # Create restored wallet
    w = Wallet()
    w.private_key = SigningKey.from_string(bytes.fromhex(private_key_hex), curve=SECP256k1)
    w.public_key = w.private_key.get_verifying_key()
    w.address = w.generate_address()

    # Derive WIF private key (compressed, mainnet)
    wif_bytes = b'\x80' + bytes.fromhex(private_key_hex) + b'\x01'  # Compressed
    wif_private = base58.b58encode_check(wif_bytes).decode()

    # Output all info
    print("\n=== Restored Wallet Information ===")
    print(f"Mnemonic (backup words): {mnemonic}")
    print(f"Private Key (hex): {private_key_hex}")
    print(f"Private Key (WIF): {wif_private}")
    print(f"Public Key (compressed hex): {w.public_key.to_string('compressed').hex()}")
    print(f"Address: {w.address}")
    if bc:
        print(f"Current Balance: {bc.get_balance(w.address)}")
    print("=== End Restoration ===")

    return w


def print_help():
    print("Usage: python restore_wallet.py [type] [value]")
    print("Type: 'mnemonic' or 'private_key'")
    print("Value: 12-24 words for mnemonic, or 64-hex chars for private key")
    print("Example: python restore_wallet.py mnemonic 'abandon ability able ...'")
    print("Interactive: Run without args for prompts.")


if __name__ == "__main__":
    if len(sys.argv) == 2 and sys.argv[1] == "--help":
        print_help()
        sys.exit(0)

    if len(sys.argv) > 2:
        # Arg mode: sys.argv[1] = type, sys.argv[2:] = value
        input_type = sys.argv[1]
        input_value = ' '.join(sys.argv[2:])
    else:
        # Interactive
        input_type = input("Restore type (mnemonic/private_key): ").strip().lower()
        if input_type not in ['mnemonic', 'private_key']:
            print("Invalid type—use 'mnemonic' or 'private_key'.")
            print_help()
            sys.exit(1)
        input_value = input("Enter value: ").strip()

    try:
        restored = restore_wallet(input_type, input_value)
        print("Restoration successful—use address for transactions.")
    except ValueError as e:
        print(f"Error: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")