crypto_wallet.py

#!/usr/bin/env python3
"""
Low Cap Charter Wallet - Professional Cryptocurrency Wallet
Enhanced with USD value display, improved blockchain connectivity, and MULTI-SEED PHRASE SUPPORT
"""

import sys
import os
import tkinter as tk
from tkinter import ttk, messagebox, filedialog
import threading
import json
import time
from pathlib import Path
from typing import Optional, Dict, Any
from decimal import Decimal

# Import our improved modules
from wallet_core import WalletCore
from transaction_manager import ImprovedTransactionManager, GasSettings
from security_manager import SecurityManager
from storage_manager import StorageManager
from ui_components import ModernUI
from qr_generator import QRGenerator
from price_fetcher import PriceFetcher

# Import the improved network manager
try:
    from network_manager import ImprovedNetworkManager
except ImportError:
    # Fallback to original if improved version not available
    from network_manager import NetworkManager as ImprovedNetworkManager

class ImprovedCryptoWallet:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("Low Cap Charter Wallet")
        self.root.geometry("1200x800")
        self.root.configure(bg="#1a1a1a")
        
        # Initialize improved managers
        self.wallet_core = WalletCore()
        self.network_manager = ImprovedNetworkManager()
        self.transaction_manager = ImprovedTransactionManager()
        self.security_manager = SecurityManager()
        self.storage_manager = StorageManager()
        self.qr_generator = QRGenerator()
        self.ui = ModernUI(self.root)
        self.price_fetcher = PriceFetcher()
        
        # Current state
        self.current_account = None
        self.current_network = None
        self.current_wallet_id = None
        self.accounts = []
        self.is_locked = True
        
        # UI variables
        self.address_var = tk.StringVar()
        self.balance_refresh_active = False
        self.auto_refresh_enabled = True
        self.last_balance_check = 0
        self.balance_cache = {}
        
        # Initialize UI and load data
        self.setup_ui()
        self.load_wallet_data()
        self.start_background_tasks()
        
    def setup_ui(self):
        """Setup the main user interface"""
        # Create main frame
        main_frame = ttk.Frame(self.root, style="Dark.TFrame")
        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # Top bar with wallet info and network selector
        self.create_top_bar(main_frame)
        
        # Main content area with tabs
        self.create_main_content(main_frame)
        
        # Bottom status bar
        self.create_status_bar(main_frame)
        
        # Setup styles
        self.ui.setup_styles()
        
    def create_top_bar(self, parent):
        """Create enhanced top navigation bar"""
        # Clear existing top bar
        for widget in parent.winfo_children():
            if isinstance(widget, ttk.Frame) and widget.winfo_children():
                first_child = widget.winfo_children()[0]
                if isinstance(first_child, ttk.Label) and "Crypto Wallet" in first_child.cget("text"):
                    widget.destroy()
                    break
        
        top_frame = ttk.Frame(parent, style="Dark.TFrame")
        top_frame.pack(fill=tk.X, pady=(0, 10))
        
        # Logo and title
        title_frame = ttk.Frame(top_frame, style="Dark.TFrame")
        title_frame.pack(side=tk.LEFT, fill=tk.Y)
        
        title_label = ttk.Label(title_frame, text="🚀 Low Cap Charter Wallet", 
                               font=("Arial", 16, "bold"), style="Title.TLabel")
        title_label.pack(side=tk.LEFT, padx=(0, 20))
        
        # Connection status indicator
        status_frame = ttk.Frame(title_frame, style="Dark.TFrame")
        status_frame.pack(side=tk.LEFT, padx=(0, 20))
        
        self.connection_indicator = tk.Label(status_frame, text="🔴", font=("Arial", 12))
        self.connection_indicator.pack(side=tk.LEFT)
        
        self.connection_status_label = ttk.Label(status_frame, text="Disconnected", 
                                               style="Light.TLabel", font=("Arial", 10))
        self.connection_status_label.pack(side=tk.LEFT, padx=(5, 0))
        
        # Network selector
        network_frame = ttk.Frame(top_frame, style="Dark.TFrame")
        network_frame.pack(side=tk.RIGHT, fill=tk.Y)
        
        ttk.Label(network_frame, text="Network:", style="Light.TLabel").pack(side=tk.LEFT, padx=(0, 5))
        
        self.network_var = tk.StringVar()
        self.network_combo = ttk.Combobox(network_frame, textvariable=self.network_var, 
                                         values=list(self.network_manager.get_networks().keys()),
                                         state="readonly", width=20)
        self.network_combo.pack(side=tk.LEFT, padx=(0, 10))
        self.network_combo.bind("<<ComboboxSelected>>", self.on_network_change)
        self.network_combo.set("Ethereum Mainnet")
        
        # Wallet controls
        controls_frame = ttk.Frame(network_frame, style="Dark.TFrame")
        controls_frame.pack(side=tk.RIGHT)
        
        if self.is_locked:
            unlock_btn = self.ui.create_button(controls_frame, "🔓 Unlock Wallet", 
                                             self.unlock_wallet, "primary")
            unlock_btn.pack(side=tk.LEFT, padx=2)
        else:
            lock_btn = self.ui.create_button(controls_frame, "🔒 Lock Wallet", 
                                           self.lock_wallet, "secondary")
            lock_btn.pack(side=tk.LEFT, padx=2)
            
        # Auto-refresh toggle
        self.auto_refresh_var = tk.BooleanVar(value=True)
        auto_refresh_check = ttk.Checkbutton(controls_frame, text="Auto Refresh", 
                                           variable=self.auto_refresh_var,
                                           command=self.toggle_auto_refresh)
        auto_refresh_check.pack(side=tk.LEFT, padx=5)
    
    def create_main_content(self, parent):
        """Create main content area with tabs"""
        # Create notebook for tabs
        self.notebook = ttk.Notebook(parent, style="Dark.TNotebook")
        self.notebook.pack(fill=tk.BOTH, expand=True)
        
        # Wallet tab
        self.wallet_tab = ttk.Frame(self.notebook, style="Dark.TFrame")
        self.notebook.add(self.wallet_tab, text="💰 Wallet")
        self.create_enhanced_wallet_tab()
        
        # Send tab
        self.send_tab = ttk.Frame(self.notebook, style="Dark.TFrame")
        self.notebook.add(self.send_tab, text="📤 Send")
        self.create_enhanced_send_tab()
        
        # Receive tab
        self.receive_tab = ttk.Frame(self.notebook, style="Dark.TFrame")
        self.notebook.add(self.receive_tab, text="📥 Receive")
        self.create_enhanced_receive_tab()
        
        # Accounts tab - NEW: Now with multi-wallet support
        self.accounts_tab = ttk.Frame(self.notebook, style="Dark.TFrame")
        self.notebook.add(self.accounts_tab, text="👤 Accounts")
        self.create_accounts_tab()
        
        # Settings tab
        self.settings_tab = ttk.Frame(self.notebook, style="Dark.TFrame")
        self.notebook.add(self.settings_tab, text="⚙️ Settings")
        self.create_settings_tab()
        
    def create_enhanced_wallet_tab(self):
        """Create enhanced wallet overview tab with real balance"""
        # Balance display with detailed info
        balance_frame = ttk.LabelFrame(self.wallet_tab, text="Portfolio Overview", 
                                     style="Dark.TLabelframe")
        balance_frame.pack(fill=tk.X, padx=10, pady=10)
        
        # Main balance display
        balance_info_frame = ttk.Frame(balance_frame, style="Dark.TFrame")
        balance_info_frame.pack(fill=tk.X, padx=10, pady=10)
        
        self.balance_label = ttk.Label(balance_info_frame, text="0.00 ETH", 
                                     font=("Arial", 24, "bold"), style="Balance.TLabel")
        self.balance_label.pack(side=tk.LEFT)
        
        # Balance controls
        balance_controls = ttk.Frame(balance_info_frame, style="Dark.TFrame")
        balance_controls.pack(side=tk.RIGHT)
        
        refresh_btn = self.ui.create_icon_button(balance_controls, "🔄", 
                                               self.manual_refresh_balance,
                                               "Refresh Balance")
        refresh_btn.pack(side=tk.RIGHT, padx=(10, 0))
        
        # Additional balance info
        balance_details_frame = ttk.Frame(balance_frame, style="Dark.TFrame")
        balance_details_frame.pack(fill=tk.X, padx=10, pady=(0, 10))
        
        self.usd_balance_label = ttk.Label(balance_details_frame, text="$0.00 USD", 
                                         font=("Arial", 14), style="Light.TLabel")
        self.usd_balance_label.pack(side=tk.LEFT)
        
        self.balance_status_label = ttk.Label(balance_details_frame, text="", 
                                            font=("Arial", 10), style="Light.TLabel")
        self.balance_status_label.pack(side=tk.RIGHT)
        
        # Quick actions with improved layout
        actions_frame = ttk.LabelFrame(self.wallet_tab, text="Quick Actions", 
                                     style="Dark.TLabelframe")
        actions_frame.pack(fill=tk.X, padx=10, pady=10)
        
        actions_inner = ttk.Frame(actions_frame, style="Dark.TFrame")
        actions_inner.pack(fill=tk.X, padx=10, pady=10)
        
        send_btn = self.ui.create_button(actions_inner, "📤 Send Funds", 
                                       lambda: self.notebook.select(1), "primary")
        send_btn.pack(side=tk.LEFT, padx=5)
        
        receive_btn = self.ui.create_button(actions_inner, "📥 Receive Funds", 
                                          lambda: self.notebook.select(2), "secondary")
        receive_btn.pack(side=tk.LEFT, padx=5)
        
        history_btn = self.ui.create_button(actions_inner, "📊 View History", 
                                          self.view_transaction_history, "accent")
        history_btn.pack(side=tk.LEFT, padx=5)
        
        test_btn = self.ui.create_button(actions_inner, "🧪 Test Connection", 
                                       self.test_network_connection, "secondary")
        test_btn.pack(side=tk.LEFT, padx=5)
        
        # Transaction history with enhanced display
        history_frame = ttk.LabelFrame(self.wallet_tab, text="Recent Transactions", 
                                     style="Dark.TLabelframe")
        history_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # Transaction controls
        tx_controls_frame = ttk.Frame(history_frame, style="Dark.TFrame")
        tx_controls_frame.pack(fill=tk.X, padx=10, pady=(10, 5))
        
        refresh_tx_btn = self.ui.create_button(tx_controls_frame, "🔄 Refresh Transactions", 
                                             self.refresh_transaction_history, "secondary")
        refresh_tx_btn.pack(side=tk.LEFT, padx=5)
        
        # Treeview for transactions
        tx_tree_frame = ttk.Frame(history_frame, style="Dark.TFrame")
        tx_tree_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=(0, 10))
        
        columns = ("Date", "Type", "Amount", "Address", "Status", "Hash")
        self.tx_tree = ttk.Treeview(tx_tree_frame, columns=columns, show="headings", 
                                   height=8, style="Dark.Treeview")
        
        # Configure columns
        column_widths = {"Date": 120, "Type": 80, "Amount": 120, "Address": 150, "Status": 80, "Hash": 100}
        for col in columns:
            self.tx_tree.heading(col, text=col)
            self.tx_tree.column(col, width=column_widths.get(col, 100))
            
        scrollbar = ttk.Scrollbar(tx_tree_frame, orient=tk.VERTICAL, command=self.tx_tree.yview)
        self.tx_tree.configure(yscrollcommand=scrollbar.set)
        
        self.tx_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # Bind double-click to view transaction details
        self.tx_tree.bind("<Double-1>", self.view_transaction_details)
        
    def create_enhanced_send_tab(self):
        """Create enhanced send transaction tab"""
        # Send form with improved validation
        form_frame = ttk.LabelFrame(self.send_tab, text="Send Transaction", 
                                  style="Dark.TLabelframe")
        form_frame.pack(fill=tk.X, padx=20, pady=20)
        
        # To address with validation
        ttk.Label(form_frame, text="To Address:", style="Light.TLabel").grid(row=0, column=0, 
                                                                            sticky=tk.W, padx=10, pady=5)
        
        to_frame = ttk.Frame(form_frame, style="Dark.TFrame")
        to_frame.grid(row=0, column=1, padx=10, pady=5, sticky=tk.EW)
        
        self.to_address_var = tk.StringVar()
        self.to_address_var.trace('w', self.validate_address)
        to_entry = ttk.Entry(to_frame, textvariable=self.to_address_var, width=45)
        to_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
        
        self.address_status_label = ttk.Label(to_frame, text="", style="Light.TLabel")
        self.address_status_label.pack(side=tk.RIGHT, padx=(10, 0))
        
        # Amount with balance check
        ttk.Label(form_frame, text="Amount:", style="Light.TLabel").grid(row=1, column=0, 
                                                                        sticky=tk.W, padx=10, pady=5)
        amount_frame = ttk.Frame(form_frame, style="Dark.TFrame")
        amount_frame.grid(row=1, column=1, padx=10, pady=5, sticky=tk.EW)
        
        self.amount_var = tk.StringVar()
        self.amount_var.trace('w', self.validate_amount)
        amount_entry = ttk.Entry(amount_frame, textvariable=self.amount_var, width=20)
        amount_entry.pack(side=tk.LEFT)
        
        self.currency_var = tk.StringVar()
        currency_combo = ttk.Combobox(amount_frame, textvariable=self.currency_var, 
                                    values=["ETH"], state="readonly", width=10)
        currency_combo.pack(side=tk.LEFT, padx=(10, 0))
        currency_combo.set("ETH")
        
        max_btn = self.ui.create_button(amount_frame, "MAX", self.set_max_amount, "secondary")
        max_btn.pack(side=tk.LEFT, padx=(10, 0))
        
        self.amount_status_label = ttk.Label(amount_frame, text="", style="Light.TLabel")
        self.amount_status_label.pack(side=tk.LEFT, padx=(10, 0))
        
        # Gas settings with real-time estimation
        gas_frame = ttk.LabelFrame(form_frame, text="Gas Settings", style="Dark.TLabelframe")
        gas_frame.grid(row=2, column=0, columnspan=2, sticky=tk.EW, padx=10, pady=10)
        
        gas_inner = ttk.Frame(gas_frame, style="Dark.TFrame")
        gas_inner.pack(fill=tk.X, padx=10, pady=10)
        
        # Gas price selection
        ttk.Label(gas_inner, text="Gas Speed:", style="Light.TLabel").grid(row=0, column=0, 
                                                                          sticky=tk.W, padx=5, pady=2)
        self.gas_speed_var = tk.StringVar(value="standard")
        gas_speed_combo = ttk.Combobox(gas_inner, textvariable=self.gas_speed_var, 
                                     values=["slow", "standard", "fast"], state="readonly", width=15)
        gas_speed_combo.grid(row=0, column=1, padx=5, pady=2)
        gas_speed_combo.bind("<<ComboboxSelected>>", self.update_gas_estimate)
        
        # Gas limit
        ttk.Label(gas_inner, text="Gas Limit:", style="Light.TLabel").grid(row=0, column=2, 
                                                                          sticky=tk.W, padx=5, pady=2)
        self.gas_limit_var = tk.StringVar(value="21000")
        ttk.Entry(gas_inner, textvariable=self.gas_limit_var, width=15).grid(row=0, column=3, 
                                                                            padx=5, pady=2)
        
        # Gas price display
        self.gas_info_label = ttk.Label(gas_inner, text="Estimating...", style="Light.TLabel")
        self.gas_info_label.grid(row=1, column=0, columnspan=4, pady=5)
        
        form_frame.columnconfigure(1, weight=1)
        
        # Transaction preview and send
        button_frame = ttk.Frame(self.send_tab, style="Dark.TFrame")
        button_frame.pack(fill=tk.X, padx=20, pady=10)
        
        estimate_btn = self.ui.create_button(button_frame, "💰 Estimate Gas", 
                                           self.estimate_transaction_gas, "secondary")
        estimate_btn.pack(side=tk.LEFT, padx=5)
        
        preview_btn = self.ui.create_button(button_frame, "🔍 Preview Transaction", 
                                          self.preview_send_transaction, "secondary")
        preview_btn.pack(side=tk.LEFT, padx=5)
        
        self.send_btn = self.ui.create_button(button_frame, "📤 Send Transaction", 
                                            self.send_transaction_confirmed, "primary")
        self.send_btn.pack(side=tk.LEFT, padx=5)
        self.send_btn.configure(state="disabled")
        
        # Transaction preview area
        self.preview_frame = ttk.LabelFrame(self.send_tab, text="Transaction Preview", 
                                          style="Dark.TLabelframe")
        self.preview_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=10)
        
        self.preview_text = tk.Text(self.preview_frame, height=8, width=80,
                                   bg=self.ui.colors['bg_secondary'], 
                                   fg=self.ui.colors['text_primary'],
                                   font=self.ui.fonts['mono'], relief='flat', borderwidth=10)
        self.preview_text.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
    def create_enhanced_receive_tab(self):
        """Create enhanced receive tab with improved QR code"""
        # Account selection for multi-account wallets
        account_frame = ttk.LabelFrame(self.receive_tab, text="Select Account", 
                                     style="Dark.TLabelframe")
        account_frame.pack(fill=tk.X, padx=20, pady=20)
        
        account_inner = ttk.Frame(account_frame, style="Dark.TFrame")
        account_inner.pack(fill=tk.X, padx=10, pady=10)
        
        ttk.Label(account_inner, text="Account:", style="Light.TLabel").pack(side=tk.LEFT)
        
        self.receive_account_var = tk.StringVar()
        self.receive_account_combo = ttk.Combobox(account_inner, textvariable=self.receive_account_var,
                                                state="readonly", width=50)
        self.receive_account_combo.pack(side=tk.LEFT, padx=(10, 0), fill=tk.X, expand=True)
        self.receive_account_combo.bind("<<ComboboxSelected>>", self.update_receive_address)
        
        # Address display with enhanced info
        addr_frame = ttk.LabelFrame(self.receive_tab, text="Receive Address", 
                                  style="Dark.TLabelframe")
        addr_frame.pack(fill=tk.X, padx=20, pady=20)
        
        addr_inner = ttk.Frame(addr_frame, style="Dark.TFrame")
        addr_inner.pack(fill=tk.X, padx=10, pady=10)
        
        # Address display
        self.receive_address_label = ttk.Label(addr_inner, text="No account selected", 
                                             font=("Courier", 11), style="Address.TLabel", 
                                             wraplength=500)
        self.receive_address_label.pack(pady=(0, 10))
        
        # Address controls
        addr_controls = ttk.Frame(addr_inner, style="Dark.TFrame")
        addr_controls.pack(fill=tk.X)
        
        copy_btn = self.ui.create_button(addr_controls, "📋 Copy Address", 
                                       self.copy_receive_address, "primary")
        copy_btn.pack(side=tk.LEFT, padx=5)
        
        show_explorer_btn = self.ui.create_button(addr_controls, "🔍 View on Explorer", 
                                                self.view_address_on_explorer, "secondary")
        show_explorer_btn.pack(side=tk.LEFT, padx=5)
        
        share_btn = self.ui.create_button(addr_controls, "📤 Share QR Code", 
                                        self.share_qr_code, "accent")
        share_btn.pack(side=tk.LEFT, padx=5)
        
        # Network warning
        self.network_warning_label = ttk.Label(addr_inner, 
                                             text="⚠️ Make sure sender uses the same network", 
                                             style="Light.TLabel", font=("Arial", 10))
        self.network_warning_label.pack(pady=(10, 0))
        
        # QR Code display with options
        qr_frame = ttk.LabelFrame(self.receive_tab, text="QR Code", 
                                style="Dark.TLabelframe")
        qr_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)
        
        qr_controls = ttk.Frame(qr_frame, style="Dark.TFrame")
        qr_controls.pack(fill=tk.X, padx=10, pady=10)
        
        qr_btn = self.ui.create_button(qr_controls, "🔄 Generate QR Code", 
                                     self.generate_receive_qr_code, "primary")
        qr_btn.pack(side=tk.LEFT, padx=5)
        
        save_qr_btn = self.ui.create_button(qr_controls, "💾 Save QR Code", 
                                          self.save_qr_code, "secondary")
        save_qr_btn.pack(side=tk.LEFT, padx=5)
        
        self.qr_label = ttk.Label(qr_frame, text="Select an account and click 'Generate QR Code'", 
                                style="Light.TLabel")
        self.qr_label.pack(expand=True, pady=20)
        
    def create_accounts_tab(self):
        """Create enhanced accounts management tab with MULTI-WALLET SUPPORT"""
        # Create notebook for wallet management
        self.accounts_notebook = ttk.Notebook(self.accounts_tab, style="Dark.TNotebook")
        self.accounts_notebook.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)
        
        # Wallets tab (seed phrase management) - NEW FEATURE
        self.wallets_tab = ttk.Frame(self.accounts_notebook, style="Dark.TFrame")
        self.accounts_notebook.add(self.wallets_tab, text="🏦 Wallets")
        self.create_wallets_management_tab()
        
        # Accounts tab (individual accounts)
        self.individual_accounts_tab = ttk.Frame(self.accounts_notebook, style="Dark.TFrame")
        self.accounts_notebook.add(self.individual_accounts_tab, text="👤 Accounts")
        self.create_individual_accounts_tab()
    
    def create_wallets_management_tab(self):
        """Create wallet (seed phrase) management tab - NEW FEATURE"""
        # Wallet list with better display
        wallet_list_frame = ttk.LabelFrame(self.wallets_tab, text="Seed Phrase Wallets", 
                                         style="Dark.TLabelframe")
        wallet_list_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # Wallet controls
        wallet_controls_frame = ttk.Frame(wallet_list_frame, style="Dark.TFrame")
        wallet_controls_frame.pack(fill=tk.X, padx=10, pady=10)
        
        create_wallet_btn = self.ui.create_button(wallet_controls_frame, "🆕 Create New Seed Phrase Wallet", 
                                                self.create_new_seed_phrase_wallet, "primary")
        create_wallet_btn.pack(side=tk.LEFT, padx=5)
        
        import_wallet_btn = self.ui.create_button(wallet_controls_frame, "📥 Import Seed Phrase Wallet", 
                                                self.import_seed_phrase_wallet, "secondary")
        import_wallet_btn.pack(side=tk.LEFT, padx=5)
        
        switch_wallet_btn = self.ui.create_button(wallet_controls_frame, "🔄 Switch Active Wallet", 
                                                self.switch_seed_phrase_wallet, "accent")
        switch_wallet_btn.pack(side=tk.LEFT, padx=5)
        
        # Wallet treeview
        wallet_tree_frame = ttk.Frame(wallet_list_frame, style="Dark.TFrame")
        wallet_tree_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=(0, 10))
        
        wallet_columns = ("Name", "Created", "Accounts", "Total Balance", "Status")
        self.wallet_tree = ttk.Treeview(wallet_tree_frame, columns=wallet_columns, show="headings", 
                                      height=8, style="Dark.Treeview")
        
        # Configure wallet columns
        wallet_column_widths = {"Name": 200, "Created": 120, "Accounts": 80, "Total Balance": 150, "Status": 100}
        for col in wallet_columns:
            self.wallet_tree.heading(col, text=col)
            self.wallet_tree.column(col, width=wallet_column_widths.get(col, 100))
            
        wallet_scrollbar = ttk.Scrollbar(wallet_tree_frame, orient=tk.VERTICAL, command=self.wallet_tree.yview)
        self.wallet_tree.configure(yscrollcommand=wallet_scrollbar.set)
        
        self.wallet_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        wallet_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # Bind wallet selection event
        self.wallet_tree.bind("<<TreeviewSelect>>", self.on_wallet_select)
        
        # Wallet security actions
        wallet_security_frame = ttk.Frame(wallet_list_frame, style="Dark.TFrame")
        wallet_security_frame.pack(fill=tk.X, padx=10, pady=10)
        
        view_seed_btn = self.ui.create_button(wallet_security_frame, "👁️ View Seed Phrase", 
                                            self.view_current_seed_phrase, "accent")
        view_seed_btn.pack(side=tk.LEFT, padx=5)
        
        export_wallet_btn = self.ui.create_button(wallet_security_frame, "📤 Export Wallet", 
                                                self.export_current_wallet, "secondary")
        export_wallet_btn.pack(side=tk.LEFT, padx=5)
    
    def create_individual_accounts_tab(self):
        """Create individual accounts management tab"""
        # Account list with better display
        list_frame = ttk.LabelFrame(self.individual_accounts_tab, text="Accounts Overview", 
                                  style="Dark.TLabelframe")
        list_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # Account controls
        controls_frame = ttk.Frame(list_frame, style="Dark.TFrame")
        controls_frame.pack(fill=tk.X, padx=10, pady=10)
        
        create_btn = self.ui.create_button(controls_frame, "➕ Create Account", 
                                         self.create_new_account, "primary")
        create_btn.pack(side=tk.LEFT, padx=5)
        
        import_btn = self.ui.create_button(controls_frame, "📥 Import Account", 
                                         self.import_account, "secondary")
        import_btn.pack(side=tk.LEFT, padx=5)
        
        refresh_accounts_btn = self.ui.create_button(controls_frame, "🔄 Refresh Balances", 
                                                   self.refresh_all_account_balances, "secondary")
        refresh_accounts_btn.pack(side=tk.LEFT, padx=5)
        
        # Account treeview with enhanced columns
        tree_frame = ttk.Frame(list_frame, style="Dark.TFrame")
        tree_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=(0, 10))
        
        acc_columns = ("Name", "Address", "Balance", "Wallet", "Status")
        self.acc_tree = ttk.Treeview(tree_frame, columns=acc_columns, show="headings", 
                                   height=10, style="Dark.Treeview")
        
        # Configure account columns
        acc_column_widths = {"Name": 120, "Address": 200, "Balance": 120, "Wallet": 150, "Status": 80}
        for col in acc_columns:
            self.acc_tree.heading(col, text=col)
            self.acc_tree.column(col, width=acc_column_widths.get(col, 100))
            
        acc_scrollbar = ttk.Scrollbar(tree_frame, orient=tk.VERTICAL, command=self.acc_tree.yview)
        self.acc_tree.configure(yscrollcommand=acc_scrollbar.set)
        
        self.acc_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        acc_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # Account actions
        acc_actions_frame = ttk.Frame(self.individual_accounts_tab, style="Dark.TFrame")
        acc_actions_frame.pack(fill=tk.X, padx=10, pady=10)
        
        switch_btn = self.ui.create_button(acc_actions_frame, "🔄 Switch Account", 
                                         self.switch_active_account, "primary")
        switch_btn.pack(side=tk.LEFT, padx=5)
        
        export_btn = self.ui.create_button(acc_actions_frame, "📤 Export Account", 
                                         self.export_account, "accent")
        export_btn.pack(side=tk.LEFT, padx=5)
        
        view_private_key_btn = self.ui.create_button(acc_actions_frame, "🔑 View Private Key", 
                                                   self.view_account_private_key, "secondary")
        view_private_key_btn.pack(side=tk.LEFT, padx=5)
        
        # Bind selection event
        self.acc_tree.bind("<<TreeviewSelect>>", self.on_account_select)
        
    def create_settings_tab(self):
        """Create enhanced settings tab"""
        # Network settings with testing
        network_frame = ttk.LabelFrame(self.settings_tab, text="Network Settings", 
                                     style="Dark.TLabelframe")
        network_frame.pack(fill=tk.X, padx=20, pady=20)
        
        network_inner = ttk.Frame(network_frame, style="Dark.TFrame")
        network_inner.pack(fill=tk.X, padx=10, pady=10)
        
        test_networks_btn = self.ui.create_button(network_inner, "🧪 Test All Networks", 
                                                self.test_all_networks, "primary")
        test_networks_btn.pack(side=tk.LEFT, padx=5)
        
        add_network_btn = self.ui.create_button(network_inner, "🌐 Add Custom Network", 
                                              self.add_custom_network, "secondary")
        add_network_btn.pack(side=tk.LEFT, padx=5)
        
        optimize_btn = self.ui.create_button(network_inner, "⚡ Optimize RPCs", 
                                           self.optimize_network_rpcs, "accent")
        optimize_btn.pack(side=tk.LEFT, padx=5)
        
        # Security settings
        security_frame = ttk.LabelFrame(self.settings_tab, text="Security Settings", 
                                      style="Dark.TLabelframe")
        security_frame.pack(fill=tk.X, padx=20, pady=20)
        
        security_inner = ttk.Frame(security_frame, style="Dark.TFrame")
        security_inner.pack(fill=tk.X, padx=10, pady=10)
        
        change_pw_btn = self.ui.create_button(security_inner, "🔑 Change Password", 
                                            self.change_password, "primary")
        change_pw_btn.pack(side=tk.LEFT, padx=5)
        
        backup_btn = self.ui.create_button(security_inner, "💾 Backup Wallet", 
                                         self.backup_wallet, "secondary")
        backup_btn.pack(side=tk.LEFT, padx=5)
        
        # Application settings
        app_frame = ttk.LabelFrame(self.settings_tab, text="Application Settings", 
                                 style="Dark.TLabelframe")
        app_frame.pack(fill=tk.X, padx=20, pady=20)
        
        app_inner = ttk.Frame(app_frame, style="Dark.TFrame")
        app_inner.pack(fill=tk.X, padx=10, pady=10)
        
        # Auto-refresh settings
        ttk.Label(app_inner, text="Auto-refresh interval (seconds):", style="Light.TLabel").pack(anchor=tk.W)
        
        self.refresh_interval_var = tk.StringVar(value="30")
        refresh_interval_entry = ttk.Entry(app_inner, textvariable=self.refresh_interval_var, width=10)
        refresh_interval_entry.pack(anchor=tk.W, pady=5)
        
        apply_settings_btn = self.ui.create_button(app_inner, "✅ Apply Settings", 
                                                 self.apply_settings, "primary")
        apply_settings_btn.pack(anchor=tk.W, pady=10)
    
    def create_status_bar(self, parent):
        """Create enhanced bottom status bar"""
        status_frame = ttk.Frame(parent, style="Dark.TFrame")
        status_frame.pack(fill=tk.X, side=tk.BOTTOM)
        
        self.status_label = ttk.Label(status_frame, text="Ready", style="Light.TLabel")
        self.status_label.pack(side=tk.LEFT, padx=5)
        
        # Last update time
        self.last_update_label = ttk.Label(status_frame, text="", style="Light.TLabel")
        self.last_update_label.pack(side=tk.LEFT, padx=20)
        
        # Network connection status
        self.connection_label = ttk.Label(status_frame, text="🔴 Disconnected", 
                                        style="Light.TLabel")
        self.connection_label.pack(side=tk.RIGHT, padx=5)
    
    # =============================================================================
    # NEW MULTI-SEED PHRASE WALLET MANAGEMENT METHODS
    # =============================================================================
    
    def create_new_seed_phrase_wallet(self):
        """Create a new seed phrase wallet (completely separate wallet)"""
        dialog = self.ui.create_modal_dialog("Create New Seed Phrase Wallet", 500, 400)
        
        # Wallet name input
        name_group = self.ui.create_input_group(dialog, "Wallet Name:", 
                                               "Enter wallet name", "text", 40)
        name_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Password input
        password_group = self.ui.create_input_group(dialog, "Wallet Password:", 
                                                   "Enter password for this wallet", "password", 40)
        password_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        confirm_group = self.ui.create_input_group(dialog, "Confirm Password:", 
                                                  "Re-enter password", "password", 40)
        confirm_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(fill=tk.X, padx=20, pady=20)
        
        generate_btn = self.ui.create_button(btn_frame, "🎲 Generate New Wallet", 
                                           lambda: self.generate_new_seed_phrase_wallet(dialog, name_group, password_group, confirm_group), 
                                           "primary")
        generate_btn.pack(side=tk.LEFT, padx=5)
        
        cancel_btn = self.ui.create_button(btn_frame, "❌ Cancel", 
                                         lambda: dialog.destroy(), "secondary")
        cancel_btn.pack(side=tk.RIGHT, padx=5)
    
    def generate_new_seed_phrase_wallet(self, dialog, name_group, password_group, confirm_group):
        """Generate and create new seed phrase wallet"""
        wallet_name = name_group["input"].get()
        password = password_group["input"].get()
        confirm = confirm_group["input"].get()
        
        if not wallet_name:
            messagebox.showerror("Error", "Please enter a wallet name!")
            return
        
        if password != confirm:
            messagebox.showerror("Error", "Passwords do not match!")
            return
        
        if len(password) < 8:
            messagebox.showerror("Error", "Password must be at least 8 characters!")
            return
        
        try:
            # Generate new mnemonic
            mnemonic = self.wallet_core.generate_mnemonic()
            
            # Create wallet in storage
            wallet_id = self.storage_manager.create_wallet(wallet_name, password, mnemonic)
            
            if wallet_id:
                dialog.destroy()
                self.show_new_seed_phrase_dialog(mnemonic, wallet_id, wallet_name)
            else:
                messagebox.showerror("Error", "Failed to create wallet!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to create wallet: {str(e)}")
    
    def show_new_seed_phrase_dialog(self, mnemonic, wallet_id, wallet_name):
        """Show seed phrase for new wallet"""
        dialog = self.ui.create_modal_dialog("New Seed Phrase Wallet Created", 700, 550)
        
        # Success message
        success_text = f"✅ New wallet '{wallet_name}' created successfully!\n\n⚠️ CRITICAL: Save your seed phrase securely!"
        
        success_label = ttk.Label(dialog, text=success_text, style="Light.TLabel", 
                                 wraplength=650, justify='center')
        success_label.pack(pady=20, padx=20)
        
        # Seed phrase display
        seed_frame = ttk.LabelFrame(dialog, text="Your New Seed Phrase", style="Dark.TLabelframe")
        seed_frame.pack(fill=tk.X, padx=20, pady=20)
        
        seed_text = tk.Text(seed_frame, height=4, width=60, wrap=tk.WORD,
                           bg=self.ui.colors['bg_secondary'], 
                           fg=self.ui.colors['text_primary'],
                           font=self.ui.fonts['mono'], relief='flat', borderwidth=10)
        seed_text.pack(padx=10, pady=10)
        seed_text.insert('1.0', mnemonic)
        seed_text.config(state='disabled')
        
        # Important notes
        notes_text = """📝 Important Notes:
• This seed phrase is completely separate from your other wallets
• Write it down and store it in a secure location
• Anyone with this phrase can access this wallet
• You can switch between wallets using the wallet management tab"""
        
        notes_label = ttk.Label(dialog, text=notes_text, style="Light.TLabel", 
                               wraplength=650, justify='left')
        notes_label.pack(pady=10, padx=20)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        copy_btn = self.ui.create_button(btn_frame, "📋 Copy to Clipboard", 
                                       lambda: self.copy_to_clipboard(mnemonic), "secondary")
        copy_btn.pack(side=tk.LEFT, padx=10)
        
        continue_btn = self.ui.create_button(btn_frame, "✅ I've Saved It - Continue", 
                                           lambda: self.complete_new_wallet_setup(dialog, wallet_id), "primary")
        continue_btn.pack(side=tk.LEFT, padx=10)
    
    def complete_new_wallet_setup(self, dialog, wallet_id):
        """Complete new wallet setup"""
        try:
            dialog.destroy()
            
            # Refresh wallet list
            self.refresh_wallet_list()
            
            # Show success message
            success_msg = f"Wallet created successfully!\n\nTo use this wallet:\n"
            success_msg += f"1. Go to the Wallets tab in Accounts\n"
            success_msg += f"2. Select the new wallet and click 'Switch Active Wallet'\n"
            success_msg += f"3. Enter the password you set for this wallet"
            
            messagebox.showinfo("Success", success_msg)
            
            # Switch to accounts tab to show the new wallet
            self.notebook.select(3)  # Accounts tab
            
        except Exception as e:
            dialog.destroy()
            messagebox.showerror("Error", f"Failed to complete setup: {str(e)}")
    
    def import_seed_phrase_wallet(self):
        """Import an existing seed phrase as a new wallet"""
        dialog = self.ui.create_modal_dialog("Import Seed Phrase Wallet", 600, 500)
        
        # Wallet name input
        name_group = self.ui.create_input_group(dialog, "Wallet Name:", 
                                               "Enter name for this wallet", "text", 40)
        name_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Seed phrase input
        seed_group = self.ui.create_input_group(dialog, "Seed Phrase:", 
                                               "Enter your 12 or 24 word seed phrase", "textarea", 50)
        seed_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Password input
        password_group = self.ui.create_input_group(dialog, "Set Password:", 
                                                   "Enter password for this wallet", "password", 40)
        password_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(fill=tk.X, padx=20, pady=20)
        
        import_btn = self.ui.create_button(btn_frame, "📥 Import Wallet", 
                                         lambda: self.perform_seed_phrase_import(dialog, name_group, seed_group, password_group), 
                                         "primary")
        import_btn.pack(side=tk.LEFT, padx=5)
        
        cancel_btn = self.ui.create_button(btn_frame, "❌ Cancel", 
                                         lambda: dialog.destroy(), "secondary")
        cancel_btn.pack(side=tk.RIGHT, padx=5)
    
    def perform_seed_phrase_import(self, dialog, name_group, seed_group, password_group):
        """Perform the seed phrase wallet import"""
        wallet_name = name_group["input"].get()
        seed_phrase = seed_group["input"].get('1.0', tk.END).strip()
        password = password_group["input"].get()
        
        if not wallet_name:
            messagebox.showerror("Error", "Please enter a wallet name!")
            return
        
        if not seed_phrase:
            messagebox.showerror("Error", "Please enter a seed phrase!")
            return
        
        if len(password) < 8:
            messagebox.showerror("Error", "Password must be at least 8 characters!")
            return
        
        try:
            # Validate seed phrase
            if not self.wallet_core.validate_mnemonic(seed_phrase):
                messagebox.showerror("Error", "Invalid seed phrase!")
                return
            
            # Create wallet
            wallet_id = self.storage_manager.create_wallet(wallet_name, password, seed_phrase)
            
            if wallet_id:
                dialog.destroy()
                self.refresh_wallet_list()
                
                success_msg = f"Wallet '{wallet_name}' imported successfully!\n\n"
                success_msg += f"To use this wallet, go to the Wallets tab and switch to it."
                
                messagebox.showinfo("Success", success_msg)
                
                # Switch to accounts tab
                self.notebook.select(3)  # Accounts tab
            else:
                messagebox.showerror("Error", "Failed to import wallet!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to import wallet: {str(e)}")
    
    def switch_seed_phrase_wallet(self):
        """Switch to a different seed phrase wallet"""
        wallets = self.storage_manager.get_wallets()
        if not wallets:
            messagebox.showwarning("Warning", "No wallets available!")
            return
        
        dialog = self.ui.create_modal_dialog("Switch Seed Phrase Wallet", 500, 300)
        
        # Wallet selection
        ttk.Label(dialog, text="Select wallet to switch to:", style="Light.TLabel").pack(pady=10)
        
        wallet_var = tk.StringVar()
        wallet_combo = ttk.Combobox(dialog, textvariable=wallet_var, 
                                   values=[f"{w['name']} (Created: {time.strftime('%Y-%m-%d', time.localtime(w['created_at']))})" for w in wallets], 
                                   state="readonly", width=50)
        wallet_combo.pack(pady=10, padx=20)
        wallet_combo.set(wallets[0]["name"] if wallets else "")
        
        # Password input
        password_group = self.ui.create_input_group(dialog, "Password:", 
                                                   "Enter wallet password", "password", 30)
        password_group["frame"].pack(pady=10, padx=20)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        switch_btn = self.ui.create_button(btn_frame, "🔄 Switch Wallet", 
                                         lambda: self.perform_wallet_switch(dialog, wallet_var, password_group, wallets), 
                                         "primary")
        switch_btn.pack(side=tk.LEFT, padx=10)
        
        cancel_btn = self.ui.create_button(btn_frame, "❌ Cancel", 
                                         lambda: dialog.destroy(), "secondary")
        cancel_btn.pack(side=tk.LEFT, padx=10)
    
    def perform_wallet_switch(self, dialog, wallet_var, password_group, wallets):
        """Perform the wallet switch operation"""
        selected_wallet_display = wallet_var.get()
        password = password_group["input"].get()
        
        if not selected_wallet_display or not password:
            messagebox.showerror("Error", "Please select wallet and enter password!")
            return
        
        # Find the wallet by matching the display name
        wallet_name = selected_wallet_display.split(" (Created:")[0]
        wallet = next((w for w in wallets if w["name"] == wallet_name), None)
        
        if not wallet:
            messagebox.showerror("Error", "Wallet not found!")
            return
        
        try:
            # Lock current wallet
            if not self.is_locked:
                self.storage_manager.lock_wallet()
            
            # Try to unlock the selected wallet
            if self.storage_manager.unlock_wallet(wallet["wallet_id"], password):
                # Load accounts for this wallet
                accounts = self.storage_manager.get_accounts(wallet["wallet_id"])
                
                self.accounts = accounts
                self.current_account = accounts[0] if accounts else None
                self.current_wallet_id = wallet["wallet_id"]
                self.is_locked = False
                
                dialog.destroy()
                
                # Update UI
                self.update_account_ui()
                self.create_top_bar(self.root.winfo_children()[0])  # Refresh top bar
                self.manual_refresh_balance()
                self.refresh_wallet_list()
                
                # Update status
                self.update_status(f"Switched to wallet: {wallet['name']}")
                
                success_msg = f"Successfully switched to wallet '{wallet['name']}'!\n\n"
                if accounts:
                    success_msg += f"Loaded {len(accounts)} account(s)."
                else:
                    success_msg += "No accounts found. You may need to create accounts for this wallet."
                
                messagebox.showinfo("Success", success_msg)
                
                # Initialize network connection
                self.on_network_change()
                
            else:
                messagebox.showerror("Error", "Incorrect password!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to switch wallet: {str(e)}")
    
    def refresh_wallet_list(self):
        """Refresh the wallet list in the UI"""
        if not hasattr(self, 'wallet_tree'):
            return
        
        # Clear existing items
        for item in self.wallet_tree.get_children():
            self.wallet_tree.delete(item)
        
        # Get all wallets
        wallets = self.storage_manager.get_wallets()
        
        for wallet in wallets:
            # Get account count for this wallet
            try:
                accounts = self.storage_manager.get_accounts(wallet["wallet_id"])
                account_count = len(accounts)
            except:
                account_count = 0
            
            # Format created date
            created_date = time.strftime('%Y-%m-%d', time.localtime(wallet["created_at"]))
            
            # Determine status
            status = "Active" if wallet["wallet_id"] == self.current_wallet_id else "Available"
            
            # Calculate total balance (placeholder for now)
            total_balance = "0.00 ETH"  # This could be calculated if needed
            
            self.wallet_tree.insert("", "end", values=(
                wallet["name"],
                created_date,
                str(account_count),
                total_balance,
                status
            ))
    
    def on_wallet_select(self, event):
        """Handle wallet selection in the tree"""
        selection = self.wallet_tree.selection()
        if selection:
            # Get selected wallet info
            pass
    
    # =============================================================================
    # SEED PHRASE AND PRIVATE KEY VIEWING METHODS
    # =============================================================================
    
    def view_current_seed_phrase(self):
        """View seed phrase of current wallet with security confirmation"""
        if not self.current_wallet_id or self.is_locked:
            messagebox.showwarning("Warning", "Please unlock a wallet first!")
            return
        
        # Security confirmation dialog
        dialog = self.ui.create_modal_dialog("🔒 Security Confirmation", 400, 450)
        
        warning_text = """⚠️ SECURITY WARNING ⚠️

You are about to view your wallet's seed phrase.

• Never share your seed phrase with anyone
• Make sure you're in a private, secure location
• Anyone with your seed phrase can access your funds
• Consider if this is absolutely necessary

Enter your wallet password to continue:"""
        
        warning_label = ttk.Label(dialog, text=warning_text, style="Light.TLabel", 
                                 wraplength=350, justify='left')
        warning_label.pack(pady=20, padx=20)
        
        # Password input
        password_group = self.ui.create_input_group(dialog, "Wallet Password:", 
                                                   "Enter your wallet password", "password", 30)
        password_group["frame"].pack(pady=10, padx=20)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        view_btn = self.ui.create_button(btn_frame, "👁️ View Seed Phrase", 
                                       lambda: self.show_seed_phrase_securely(dialog, password_group), 
                                       "accent")
        view_btn.pack(side=tk.LEFT, padx=10)
        
        cancel_btn = self.ui.create_button(btn_frame, "❌ Cancel", 
                                         lambda: dialog.destroy(), "secondary")
        cancel_btn.pack(side=tk.LEFT, padx=10)
    
    def show_seed_phrase_securely(self, dialog, password_group):
        """Show seed phrase after password verification"""
        password = password_group["input"].get()
        
        if not password:
            messagebox.showerror("Error", "Please enter your password!")
            return
        
        try:
            # Verify password by trying to unlock
            temp_storage = StorageManager()
            if temp_storage.unlock_wallet(self.current_wallet_id, password):
                # Get seed phrase
                seed_phrase = temp_storage.get_seed_phrase(self.current_wallet_id)
                temp_storage.lock_wallet()  # Lock immediately after getting seed
                
                if seed_phrase:
                    dialog.destroy()
                    self.display_seed_phrase_dialog(seed_phrase)
                else:
                    messagebox.showerror("Error", "Could not retrieve seed phrase!")
            else:
                messagebox.showerror("Error", "Incorrect password!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to verify password: {str(e)}")
    
    def display_seed_phrase_dialog(self, seed_phrase):
        """Display the seed phrase in a secure dialog"""
        dialog = self.ui.create_modal_dialog("🔑 Your Wallet Seed Phrase", 700, 500)
        
        # Get current wallet name
        wallets = self.storage_manager.get_wallets()
        current_wallet = next((w for w in wallets if w["wallet_id"] == self.current_wallet_id), None)
        wallet_name = current_wallet["name"] if current_wallet else "Unknown"
        
        # Header
        header_text = f"Seed Phrase for: {wallet_name}\n\n⚠️ Keep this information secure and private!"
        header_label = ttk.Label(dialog, text=header_text, style="Light.TLabel", 
                                wraplength=650, justify='center')
        header_label.pack(pady=20, padx=20)
        
        # Seed phrase display
        seed_frame = ttk.LabelFrame(dialog, text="Your Seed Phrase", style="Dark.TLabelframe")
        seed_frame.pack(fill=tk.X, padx=20, pady=20)
        
        seed_text = tk.Text(seed_frame, height=4, width=60, wrap=tk.WORD,
                           bg=self.ui.colors['bg_secondary'], 
                           fg=self.ui.colors['text_primary'],
                           font=self.ui.fonts['mono'], relief='flat', borderwidth=10)
        seed_text.pack(padx=10, pady=10)
        seed_text.insert('1.0', seed_phrase)
        seed_text.config(state='disabled')
        
        # Security reminder
        reminder_text = """🔒 Security Reminders:
• Write this down on paper and store it safely
• Never store it digitally or take screenshots
• This phrase can restore your entire wallet
• Anyone with this phrase has full access to your funds"""
        
        reminder_label = ttk.Label(dialog, text=reminder_text, style="Light.TLabel", 
                                  wraplength=650, justify='left')
        reminder_label.pack(pady=10, padx=20)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        copy_btn = self.ui.create_button(btn_frame, "📋 Copy to Clipboard", 
                                       lambda: self.copy_seed_phrase_securely(seed_phrase), "secondary")
        copy_btn.pack(side=tk.LEFT, padx=10)
        
        close_btn = self.ui.create_button(btn_frame, "✅ I've Saved It", 
                                        lambda: dialog.destroy(), "primary")
        close_btn.pack(side=tk.LEFT, padx=10)
    
    def copy_seed_phrase_securely(self, seed_phrase):
        """Copy seed phrase to clipboard with security warning"""
        result = messagebox.askyesno(
            "Security Warning", 
            "Copying seed phrase to clipboard can be risky!\n\n"
            "The clipboard might be accessible to other applications.\n"
            "Make sure to clear clipboard after use.\n\n"
            "Continue?"
        )
        
        if result:
            self.copy_to_clipboard(seed_phrase)
            messagebox.showinfo("Copied", 
                              "Seed phrase copied to clipboard.\n"
                              "Remember to clear clipboard when done!")
    
    def view_account_private_key(self):
        """View private key of selected account"""
        if not self.current_account or self.is_locked:
            messagebox.showwarning("Warning", "Please select an account first!")
            return
        
        # Get selected account from tree if different from current
        selection = self.acc_tree.selection()
        if selection:
            item = self.acc_tree.item(selection[0])
            values = item['values']
            account_name = values[0]
            selected_account = next((acc for acc in self.accounts if acc['name'] == account_name), None)
        else:
            selected_account = self.current_account
        
        if not selected_account:
            messagebox.showwarning("Warning", "No account selected!")
            return
        
        # Security confirmation dialog
        dialog = self.ui.create_modal_dialog("🔒 Security Confirmation", 400, 300)
        
        warning_text = f"""⚠️ SECURITY WARNING ⚠️

You are about to view the private key for:
Account: {selected_account['name']}
Address: {selected_account['address'][:20]}...

• Never share your private key with anyone
• Make sure you're in a private, secure location
• Anyone with your private key can access this account
• Consider if this is absolutely necessary

Enter your wallet password to continue:"""
        
        warning_label = ttk.Label(dialog, text=warning_text, style="Light.TLabel", 
                                 wraplength=350, justify='left')
        warning_label.pack(pady=20, padx=20)
        
        # Password input
        password_group = self.ui.create_input_group(dialog, "Wallet Password:", 
                                                   "Enter your wallet password", "password", 30)
        password_group["frame"].pack(pady=10, padx=20)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        view_btn = self.ui.create_button(btn_frame, "🔑 View Private Key", 
                                       lambda: self.show_private_key_securely(dialog, password_group, selected_account), 
                                       "accent")
        view_btn.pack(side=tk.LEFT, padx=10)
        
        cancel_btn = self.ui.create_button(btn_frame, "❌ Cancel", 
                                         lambda: dialog.destroy(), "secondary")
        cancel_btn.pack(side=tk.LEFT, padx=10)
    
    def show_private_key_securely(self, dialog, password_group, account):
        """Show private key after password verification"""
        password = password_group["input"].get()
        
        if not password:
            messagebox.showerror("Error", "Please enter your password!")
            return
        
        try:
            # Verify password by trying to unlock
            temp_storage = StorageManager()
            if temp_storage.unlock_wallet(self.current_wallet_id, password):
                # Get private key
                private_key = temp_storage.get_private_key(account.get('account_id'))
                temp_storage.lock_wallet()  # Lock immediately after getting key
                
                # If account_id is not available, try to get from stored private key
                if not private_key and 'private_key' in account:
                    private_key = account['private_key']
                
                if private_key:
                    dialog.destroy()
                    self.display_private_key_dialog(private_key, account)
                else:
                    messagebox.showerror("Error", "Could not retrieve private key!")
            else:
                messagebox.showerror("Error", "Incorrect password!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to verify password: {str(e)}")
    
    def display_private_key_dialog(self, private_key, account):
        """Display the private key in a secure dialog"""
        dialog = self.ui.create_modal_dialog("🔑 Account Private Key", 700, 500)
        
        # Header
        header_text = f"""Private Key for Account: {account['name']}
Address: {account['address']}

⚠️ Keep this information secure and private!"""
        
        header_label = ttk.Label(dialog, text=header_text, style="Light.TLabel", 
                                wraplength=650, justify='center')
        header_label.pack(pady=20, padx=20)
        
        # Private key display
        key_frame = ttk.LabelFrame(dialog, text="Private Key", style="Dark.TLabelframe")
        key_frame.pack(fill=tk.X, padx=20, pady=20)
        
        key_text = tk.Text(key_frame, height=3, width=70, wrap=tk.WORD,
                          bg=self.ui.colors['bg_secondary'], 
                          fg=self.ui.colors['text_primary'],
                          font=self.ui.fonts['mono'], relief='flat', borderwidth=10)
        key_text.pack(padx=10, pady=10)
        key_text.insert('1.0', private_key)
        key_text.config(state='disabled')
        
        # Account info
        info_frame = ttk.LabelFrame(dialog, text="Account Information", style="Dark.TLabelframe")
        info_frame.pack(fill=tk.X, padx=20, pady=10)
        
        info_text = f"""Address: {account['address']}
Derivation Path: {account.get('derivation_path', 'N/A')}
Account Index: {account.get('account_index', 'N/A')}"""
        
        info_label = ttk.Label(info_frame, text=info_text, style="Light.TLabel", 
                              font=self.ui.fonts['mono'])
        info_label.pack(padx=10, pady=10)
        
        # Security reminder
        reminder_text = """🔒 Security Reminders:
• Never share this private key with anyone
• This key controls only this specific account
• Store it safely - anyone with this key can access this account"""
        
        reminder_label = ttk.Label(dialog, text=reminder_text, style="Light.TLabel", 
                                  wraplength=650, justify='left')
        reminder_label.pack(pady=10, padx=20)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        copy_btn = self.ui.create_button(btn_frame, "📋 Copy to Clipboard", 
                                       lambda: self.copy_private_key_securely(private_key), "secondary")
        copy_btn.pack(side=tk.LEFT, padx=10)
        
        close_btn = self.ui.create_button(btn_frame, "✅ Close", 
                                        lambda: dialog.destroy(), "primary")
        close_btn.pack(side=tk.LEFT, padx=10)
    
    def copy_private_key_securely(self, private_key):
        """Copy private key to clipboard with security warning"""
        result = messagebox.askyesno(
            "Security Warning", 
            "Copying private key to clipboard can be risky!\n\n"
            "The clipboard might be accessible to other applications.\n"
            "Make sure to clear clipboard after use.\n\n"
            "Continue?"
        )
        
        if result:
            self.copy_to_clipboard(private_key)
            messagebox.showinfo("Copied", 
                              "Private key copied to clipboard.\n"
                              "Remember to clear clipboard when done!")
    
    def export_current_wallet(self):
        """Export current wallet information"""
        if not self.current_wallet_id or self.is_locked:
            messagebox.showwarning("Warning", "Please unlock a wallet first!")
            return
        
        messagebox.showinfo("Export Wallet", 
                           "Wallet export functionality will be implemented.\n"
                           "This will include encrypted backup options.")
    
    # =============================================================================
    # BACKGROUND TASKS AND UI UPDATES
    # =============================================================================
    
    def start_background_tasks(self):
        """Start background tasks for balance monitoring"""
        self.update_connection_status()
        if self.auto_refresh_enabled and not self.is_locked:
            self.schedule_balance_refresh()
        
        # Refresh wallet list after UI is loaded
        self.root.after(1000, self.refresh_wallet_list)
    
    def schedule_balance_refresh(self):
        """Schedule automatic balance refresh"""
        if self.auto_refresh_enabled and not self.is_locked and self.current_account:
            try:
                refresh_interval = int(self.refresh_interval_var.get()) * 1000
            except:
                refresh_interval = 30000  # 30 seconds default
            
            self.root.after(refresh_interval, self.auto_refresh_balance)
    
    def auto_refresh_balance(self):
        """Automatically refresh balance in background"""
        if self.auto_refresh_enabled and not self.is_locked and self.current_account:
            threading.Thread(target=self._background_refresh_balance, daemon=True).start()
            self.schedule_balance_refresh()
    
    def _background_refresh_balance(self):
        """Background balance refresh without blocking UI"""
        try:
            if not self.current_account or not self.current_network:
                return
            
            balance_info = self.transaction_manager.get_balance(
                self.current_account['address'], 
                self.current_network
            )
            
            if 'error' not in balance_info:
                # Update UI in main thread
                self.root.after(0, lambda: self._update_balance_display(balance_info))
        except Exception as e:
            print(f"Background balance refresh failed: {e}")
    
    def _update_balance_display(self, balance_info):
        """Update balance display in main thread with USD value"""
        try:
            balance = balance_info.get('balance', '0')
            symbol = balance_info.get('symbol', 'ETH')
            
            # Get USD value
            try:
                usd_value = self.price_fetcher.calculate_usd_value(
                    balance, symbol, self.current_network.name if self.current_network else ""
                )
                usd_text = self.price_fetcher.format_usd_value(usd_value)
            except:
                usd_text = "~"
            
            self.balance_label.config(text=f"{balance} {symbol}")
            self.usd_balance_label.config(text=f"{usd_text} USD")
            self.balance_status_label.config(text=f"Updated: {time.strftime('%H:%M:%S')}")
            
            # Update cache
            cache_key = f"{self.current_account['address']}_{self.current_network.name}"
            self.balance_cache[cache_key] = {
                'balance': balance,
                'symbol': symbol,
                'usd_value': usd_value,
                'timestamp': time.time()
            }
            
        except Exception as e:
            print(f"Failed to update balance display: {e}")
    
    def update_connection_status(self):
        """Update network connection status"""
        def check_connection():
            if self.current_network:
                working_rpc = self.network_manager.get_working_rpc(self.current_network)
                status = "🟢 Connected" if working_rpc else "🔴 Disconnected"
                self.root.after(0, lambda: self.connection_label.config(text=status))
                self.root.after(0, lambda: self.connection_indicator.config(
                    text="🟢" if working_rpc else "🔴"))
                self.root.after(0, lambda: self.connection_status_label.config(
                    text="Connected" if working_rpc else "Disconnected"))
        
        threading.Thread(target=check_connection, daemon=True).start()
        # Schedule next check
        self.root.after(10000, self.update_connection_status)  # Check every 10 seconds
    
    def toggle_auto_refresh(self):
        """Toggle auto-refresh functionality"""
        self.auto_refresh_enabled = self.auto_refresh_var.get()
        if self.auto_refresh_enabled:
            self.schedule_balance_refresh()
            self.update_status("Auto-refresh enabled")
        else:
            self.update_status("Auto-refresh disabled")
    
    def manual_refresh_balance(self):
        """Manually refresh balance"""
        if self.balance_refresh_active:
            return
        
        self.balance_refresh_active = True
        self.balance_status_label.config(text="Refreshing...")
        
        def refresh():
            try:
                self.refresh_balance()
            finally:
                self.balance_refresh_active = False
        
        threading.Thread(target=refresh, daemon=True).start()
    
    def refresh_balance(self):
        """Enhanced balance refresh with USD value"""
        if not self.current_account or self.is_locked:
            return
        
        try:
            network = self.network_manager.get_network(self.network_var.get())
            if not network:
                self.balance_label.config(text="Network error")
                return
            
            # Test connection first
            working_rpc = self.network_manager.get_working_rpc(network)
            if not working_rpc:
                self.balance_label.config(text="Connection failed")
                self.update_status("No working RPC found")
                return
            
            balance_info = self.transaction_manager.get_balance(
                self.current_account['address'], 
                network
            )
            
            if 'error' not in balance_info:
                balance = balance_info.get('balance', '0')
                symbol = balance_info.get('symbol', 'ETH')
                
                # Get USD value
                try:
                    usd_value = self.price_fetcher.calculate_usd_value(
                        balance, symbol, network.name
                    )
                    usd_text = self.price_fetcher.format_usd_value(usd_value)
                except:
                    usd_text = "~"
                
                # Update display in main thread
                self.root.after(0, lambda: self.balance_label.config(text=f"{balance} {symbol}"))
                self.root.after(0, lambda: self.usd_balance_label.config(text=f"{usd_text} USD"))
                self.root.after(0, lambda: self.balance_status_label.config(
                    text=f"Updated: {time.strftime('%H:%M:%S')}"))
                
                # Update cache if we have storage manager access
                try:
                    if hasattr(self, 'storage_manager') and not self.is_locked:
                        account_id = self.current_account.get('account_id')
                        if account_id:
                            self.storage_manager.update_balance_cache(
                                account_id, self.network_var.get(), balance
                            )
                except Exception as e:
                    print(f"Failed to update balance cache: {e}")
            else:
                error_msg = balance_info.get('error', 'Unknown error')
                self.root.after(0, lambda: self.balance_label.config(text="Error loading balance"))
                self.root.after(0, lambda: self.usd_balance_label.config(text="$0.00 USD"))
                self.root.after(0, lambda: self.update_status(f"Balance error: {error_msg}"))
                
        except Exception as e:
            print(f"Failed to refresh balance: {e}")
            self.root.after(0, lambda: self.balance_label.config(text="Error"))
            self.root.after(0, lambda: self.usd_balance_label.config(text="$0.00 USD"))
            self.root.after(0, lambda: self.update_status(f"Balance refresh failed: {str(e)}"))
    
    def test_network_connection(self):
        """Test current network connection"""
        if not self.current_network:
            messagebox.showwarning("Warning", "No network selected!")
            return
        
        self.update_status("Testing network connection...")
        
        def test_connection():
            try:
                test_results = self.network_manager.test_rpc_connection(self.current_network)
                
                working_count = len(test_results['working_rpcs'])
                total_count = len(self.current_network.rpc_urls)
                
                message = f"Network: {self.current_network.name}\n"
                message += f"Working RPCs: {working_count}/{total_count}\n"
                
                if test_results['fastest_rpc']:
                    message += f"Fastest RPC: {test_results['fastest_rpc']}\n"
                    message += f"Average response time: {test_results['avg_response_time']:.3f}s"
                else:
                    message += "No working RPCs found!"
                
                self.root.after(0, lambda: messagebox.showinfo("Network Test Results", message))
                self.root.after(0, lambda: self.update_status("Network test completed"))
                
            except Exception as e:
                self.root.after(0, lambda: messagebox.showerror("Error", f"Network test failed: {str(e)}"))
        
        threading.Thread(target=test_connection, daemon=True).start()
    
    # =============================================================================
    # VALIDATION METHODS
    # =============================================================================
    
    def validate_address(self, *args):
        """Validate Ethereum address format"""
        address = self.to_address_var.get()
        if not address:
            self.address_status_label.config(text="", foreground=self.ui.colors['text_secondary'])
            return
        
        try:
            from web3 import Web3
            if Web3.is_address(address):
                self.address_status_label.config(text="✓ Valid", 
                                               foreground=self.ui.colors['accent_success'])
            else:
                self.address_status_label.config(text="✗ Invalid", 
                                               foreground=self.ui.colors['accent_error'])
        except:
            self.address_status_label.config(text="? Unknown", 
                                           foreground=self.ui.colors['accent_warning'])
    
    def validate_amount(self, *args):
        """Validate transaction amount"""
        amount_str = self.amount_var.get()
        if not amount_str:
            self.amount_status_label.config(text="", foreground=self.ui.colors['text_secondary'])
            self.send_btn.configure(state="disabled")
            return
        
        try:
            amount = Decimal(amount_str)
            if amount <= 0:
                self.amount_status_label.config(text="✗ Must be positive", 
                                              foreground=self.ui.colors['accent_error'])
                self.send_btn.configure(state="disabled")
                return
            
            # Check against balance
            current_balance_text = self.balance_label.cget("text")
            if "ETH" in current_balance_text:
                balance_str = current_balance_text.split()[0]
                try:
                    balance = Decimal(balance_str)
                    if amount > balance:
                        self.amount_status_label.config(text="✗ Insufficient balance", 
                                                      foreground=self.ui.colors['accent_error'])
                        self.send_btn.configure(state="disabled")
                        return
                    else:
                        self.amount_status_label.config(text="✓ Valid", 
                                                      foreground=self.ui.colors['accent_success'])
                        # Check if address is also valid before enabling send button
                        if "✓ Valid" in self.address_status_label.cget("text"):
                            self.send_btn.configure(state="normal")
                        else:
                            self.send_btn.configure(state="disabled")
                except:
                    pass
            else:
                self.amount_status_label.config(text="✓ Valid", 
                                              foreground=self.ui.colors['accent_success'])
                
        except (ValueError, TypeError):
            self.amount_status_label.config(text="✗ Invalid number", 
                                          foreground=self.ui.colors['accent_error'])
            self.send_btn.configure(state="disabled")
    
    def set_max_amount(self):
        """Set maximum available amount"""
        try:
            current_balance_text = self.balance_label.cget("text")
            if "ETH" in current_balance_text:
                balance_str = current_balance_text.split()[0]
                balance = Decimal(balance_str)
                
                # Reserve some ETH for gas fees
                max_amount = max(Decimal('0'), balance - Decimal('0.001'))
                self.amount_var.set(str(max_amount))
        except Exception as e:
            print(f"Failed to set max amount: {e}")
    
    def estimate_transaction_gas(self):
        """Estimate gas for current transaction"""
        if not self.current_account or not self.current_network:
            messagebox.showerror("Error", "No account or network selected!")
            return
        
        to_address = self.to_address_var.get()
        amount = self.amount_var.get()
        
        if not to_address or not amount:
            messagebox.showwarning("Warning", "Please enter recipient address and amount!")
            return
        
        self.gas_info_label.config(text="Estimating gas...")
        
        def estimate_gas():
            try:
                transaction_params = {
                    'from': self.current_account['address'],
                    'to': to_address,
                    'value': int(Decimal(amount) * Decimal(10**18))  # Convert to Wei
                }
                
                gas_info = self.transaction_manager.estimate_gas(transaction_params, self.current_network)
                
                if 'error' not in gas_info:
                    gas_limit = gas_info['gas_limit']
                    cost_eth = gas_info['estimated_cost_eth']
                    
                    info_text = f"Gas Limit: {gas_limit:,} | Est. Cost: {cost_eth} ETH"
                    
                    if gas_info.get('is_eip1559'):
                        base_fee_gwei = gas_info['base_fee_per_gas'] / 10**9
                        priority_fee_gwei = gas_info['max_priority_fee_per_gas'] / 10**9
                        info_text += f" | Base: {base_fee_gwei:.1f} + Priority: {priority_fee_gwei:.1f} Gwei"
                    else:
                        gas_price_gwei = gas_info['gas_price'] / 10**9
                        info_text += f" | Gas Price: {gas_price_gwei:.1f} Gwei"
                    
                    self.root.after(0, lambda: self.gas_info_label.config(text=info_text))
                    self.root.after(0, lambda: self.gas_limit_var.set(str(gas_limit)))
                else:
                    error_msg = gas_info['error']
                    self.root.after(0, lambda: self.gas_info_label.config(text=f"Error: {error_msg}"))
                    
            except Exception as e:
                self.root.after(0, lambda: self.gas_info_label.config(text=f"Error: {str(e)}"))
        
        threading.Thread(target=estimate_gas, daemon=True).start()
    
    def preview_send_transaction(self):
        """Preview transaction before sending"""
        if not self.current_account or not self.current_network:
            messagebox.showerror("Error", "No account or network selected!")
            return
        
        to_address = self.to_address_var.get()
        amount = self.amount_var.get()
        
        if not to_address or not amount:
            messagebox.showwarning("Warning", "Please enter recipient address and amount!")
            return
        
        try:
            preview_text = f"Transaction Preview:\n"
            preview_text += f"{'='*50}\n"
            preview_text += f"From: {self.current_account['address']}\n"
            preview_text += f"To: {to_address}\n"
            preview_text += f"Amount: {amount} {self.current_network.symbol}\n"
            preview_text += f"Network: {self.current_network.name}\n"
            preview_text += f"Gas Limit: {self.gas_limit_var.get()}\n"
            preview_text += f"Gas Speed: {self.gas_speed_var.get()}\n"
            preview_text += f"{'='*50}\n"
            preview_text += f"Status: Ready to send\n"
            
            self.preview_text.delete('1.0', tk.END)
            self.preview_text.insert('1.0', preview_text)
            
        except Exception as e:
            messagebox.showerror("Error", f"Failed to create preview: {str(e)}")
    
    def send_transaction_confirmed(self):
        """Send transaction after final confirmation"""
        if not self.current_account or not self.current_network:
            messagebox.showerror("Error", "No account or network selected!")
            return
        
        # Show confirmation dialog
        confirm_msg = f"Are you sure you want to send {self.amount_var.get()} {self.current_network.symbol} "
        confirm_msg += f"to {self.to_address_var.get()[:10]}...?"
        
        if not messagebox.askyesno("Confirm Transaction", confirm_msg):
            return
        
        self.send_btn.configure(state="disabled", text="Sending...")
        self.update_status("Preparing transaction...")
        
        def send_transaction():
            try:
                # Get private key for current account
                private_key = self.storage_manager.get_private_key(self.current_account.get('account_id'))
                if not private_key:
                    self.root.after(0, lambda: messagebox.showerror("Error", "Cannot access private key!"))
                    return
                
                # Build and sign transaction
                self.root.after(0, lambda: self.update_status("Building transaction..."))
                
                gas_settings = GasSettings(
                    gas_limit=int(self.gas_limit_var.get()),
                    gas_strategy=self.gas_speed_var.get()
                )
                
                tx_result = self.transaction_manager.build_transaction(
                    from_address=self.current_account['address'],
                    to_address=self.to_address_var.get(),
                    amount=self.amount_var.get(),
                    network_config=self.current_network,
                    private_key=private_key,
                    gas_settings=gas_settings
                )
                
                if 'error' in tx_result:
                    self.root.after(0, lambda: messagebox.showerror("Error", f"Transaction failed: {tx_result['error']}"))
                    return
                
                # Send transaction
                self.root.after(0, lambda: self.update_status("Broadcasting transaction..."))
                
                send_result = self.transaction_manager.send_transaction(tx_result, self.current_network)
                
                if 'error' in send_result:
                    self.root.after(0, lambda: messagebox.showerror("Error", f"Send failed: {send_result['error']}"))
                    return
                
                tx_hash = send_result['transaction_hash']
                explorer_url = send_result.get('explorer_url', '')
                
                # Show success message
                success_msg = f"Transaction sent successfully!\n\nHash: {tx_hash}\n\n"
                if explorer_url:
                    success_msg += f"View on explorer: {explorer_url}"
                
                self.root.after(0, lambda: messagebox.showinfo("Transaction Sent", success_msg))
                self.root.after(0, lambda: self.update_status(f"Transaction sent: {tx_hash[:10]}..."))
                
                # Clear form
                self.root.after(0, self.clear_send_form)
                
                # Refresh balance after a delay
                self.root.after(5000, self.manual_refresh_balance)
                
            except Exception as e:
                self.root.after(0, lambda: messagebox.showerror("Error", f"Transaction failed: {str(e)}"))
            finally:
                self.root.after(0, lambda: self.send_btn.configure(state="normal", text="📤 Send Transaction"))
        
        threading.Thread(target=send_transaction, daemon=True).start()
    
    def clear_send_form(self):
        """Clear send transaction form"""
        self.to_address_var.set("")
        self.amount_var.set("")
        self.preview_text.delete('1.0', tk.END)
        self.address_status_label.config(text="")
        self.amount_status_label.config(text="")
        self.gas_info_label.config(text="Ready for next transaction")
    
    # =============================================================================
    # RECEIVE TAB METHODS
    # =============================================================================
    
    def update_receive_address(self, event=None):
        """Update receive address when account is selected"""
        selected = self.receive_account_var.get()
        if selected and self.accounts:
            # Find selected account
            for account in self.accounts:
                if f"{account['name']} ({account['address'][:10]}...)" == selected:
                    self.receive_address_label.config(text=account['address'])
                    self.network_warning_label.config(text=f"⚠️ Make sure sender uses {self.current_network.name if self.current_network else 'the correct network'}")
                    break
    
    def copy_receive_address(self):
        """Copy receive address to clipboard"""
        address_text = self.receive_address_label.cget("text")
        if address_text and address_text != "No account selected":
            self.root.clipboard_clear()
            self.root.clipboard_append(address_text)
            self.update_status("Address copied to clipboard")
        else:
            messagebox.showwarning("Warning", "No address to copy!")
    
    def view_address_on_explorer(self):
        """Open address in block explorer"""
        address_text = self.receive_address_label.cget("text")
        if not address_text or address_text == "No account selected":
            messagebox.showwarning("Warning", "No address selected!")
            return
        
        if not self.current_network:
            messagebox.showwarning("Warning", "No network selected!")
            return
        
        try:
            import webbrowser
            explorer_url = self.current_network.block_explorer_url
            if explorer_url:
                full_url = f"{explorer_url}/address/{address_text}"
                webbrowser.open(full_url)
                self.update_status("Opened in block explorer")
            else:
                messagebox.showinfo("Info", f"No block explorer configured for {self.current_network.name}")
        except Exception as e:
            messagebox.showerror("Error", f"Failed to open explorer: {str(e)}")
    
    def generate_receive_qr_code(self):
        """Generate QR code for receive address"""
        address_text = self.receive_address_label.cget("text")
        if not address_text or address_text == "No account selected":
            messagebox.showwarning("Warning", "Please select an account first!")
            return
        
        try:
            network_name = self.current_network.name if self.current_network else "ethereum"
            
            qr_image = self.qr_generator.generate_address_qr(
                address=address_text,
                network=network_name.lower(),
                label=f"Receive on {network_name}"
            )
            
            if qr_image:
                # Convert to Tkinter image and display
                tk_image = self.qr_generator.create_tkinter_image(qr_image)
                if tk_image:
                    self.qr_label.configure(image=tk_image, text="")
                    self.qr_label.image = tk_image  # Keep reference
                    self.update_status("QR code generated")
                else:
                    self.qr_label.configure(text="QR code generated\n(Display not available)", image="")
            else:
                messagebox.showerror("Error", "Failed to generate QR code!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to generate QR code: {str(e)}")
    
    def save_qr_code(self):
        """Save QR code to file"""
        if not hasattr(self.qr_label, 'image') or not self.qr_label.image:
            messagebox.showwarning("Warning", "No QR code to save!")
            return
        
        try:
            filename = filedialog.asksaveasfilename(
                title="Save QR Code",
                defaultextension=".png",
                filetypes=[("PNG files", "*.png"), ("All files", "*.*")]
            )
            
            if filename:
                # This is a simplified version - you'd need to get the original PIL image
                messagebox.showinfo("Info", "QR code saving feature will be implemented")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to save QR code: {str(e)}")
    
    def share_qr_code(self):
        """Share QR code"""
        if not hasattr(self.qr_label, 'image') or not self.qr_label.image:
            messagebox.showwarning("Warning", "Generate a QR code first!")
            return
        
        # This could open a share dialog or copy to clipboard
        messagebox.showinfo("Info", "QR code sharing feature will be implemented")
    
    # =============================================================================
    # WALLET AND ACCOUNT MANAGEMENT
    # =============================================================================
    
    def load_wallet_data(self):
        """Load existing wallet data"""
        try:
            if self.storage_manager.wallet_exists():
                self.update_status("Wallet found. Please unlock to continue.")
                # Refresh wallet list if UI is ready
                if hasattr(self, 'wallet_tree'):
                    self.refresh_wallet_list()
            else:
                self.show_welcome_dialog()
        except Exception as e:
            messagebox.showerror("Error", f"Failed to load wallet data: {str(e)}")
    
    def show_welcome_dialog(self):
        """Show welcome dialog for new users"""
        dialog = self.ui.create_modal_dialog("Welcome to Low Cap Charter Wallet", 500, 600)
        
        # Welcome message
        welcome_text = """Welcome to Low Cap Charter Wallet!

This professional cryptocurrency wallet includes advanced features
for managing your digital assets with enhanced security and connectivity.

🆕 NEW: Multi-Seed Phrase Support!
You can now create and manage multiple separate wallets, each with 
its own seed phrase, for better organization and security.

Features:
• Multiple seed phrase wallets for organization
• Real-time balance monitoring with USD values
• Enhanced network connectivity across multiple chains
• Advanced transaction management
• Professional-grade security features
• Multi-account support within each wallet

You can:
• Create a new wallet with a secure seed phrase
• Import an existing wallet from seed phrase
• Manage multiple wallets from one interface
• Switch between different seed phrase wallets

Your wallet data will be encrypted and stored locally."""

        message_label = ttk.Label(dialog, text=welcome_text, style="Light.TLabel", 
                                 wraplength=450, justify='left')
        message_label.pack(pady=20, padx=20)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        create_btn = self.ui.create_button(btn_frame, "🆕 Create New Wallet", 
                                         lambda: self.create_new_wallet(dialog), "primary")
        create_btn.pack(pady=5, padx=20, fill=tk.X)
        
        import_btn = self.ui.create_button(btn_frame, "📥 Import Wallet", 
                                         lambda: self.import_wallet_dialog(dialog), "secondary")
        import_btn.pack(pady=5, padx=20, fill=tk.X)
    
    def create_new_wallet(self, parent_dialog=None):
        """Create a new wallet"""
        if parent_dialog:
            parent_dialog.destroy()
        
        dialog = self.ui.create_modal_dialog("Create New Wallet", 600, 500)
        
        # Password input
        password_group = self.ui.create_input_group(dialog, "Set Wallet Password:", 
                                                   "Enter a strong password", "password", 40)
        password_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        confirm_group = self.ui.create_input_group(dialog, "Confirm Password:", 
                                                  "Re-enter password", "password", 40)
        confirm_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Generate button
        generate_btn = self.ui.create_button(dialog, "🎲 Generate Wallet", 
                                           lambda: self.generate_wallet(dialog, password_group, confirm_group), 
                                           "primary")
        generate_btn.pack(pady=20)
    
    def generate_wallet(self, dialog, password_group, confirm_group):
        """Generate new wallet with seed phrase"""
        password = password_group["input"].get()
        confirm = confirm_group["input"].get()
        
        if password != confirm:
            messagebox.showerror("Error", "Passwords do not match!")
            return
        
        if len(password) < 8:
            messagebox.showerror("Error", "Password must be at least 8 characters!")
            return
        
        try:
            # Generate new mnemonic
            mnemonic = self.wallet_core.generate_mnemonic()
            
            # Create wallet in storage
            wallet_id = self.storage_manager.create_wallet("Low Cap Charter Wallet", password, mnemonic)
            
            if wallet_id:
                self.current_wallet_id = wallet_id
                dialog.destroy()
                self.show_seed_phrase_dialog(mnemonic, wallet_id)
            else:
                messagebox.showerror("Error", "Failed to create wallet!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to create wallet: {str(e)}")
    
    def show_seed_phrase_dialog(self, mnemonic, wallet_id):
        """Show seed phrase to user"""
        dialog = self.ui.create_modal_dialog("Your Seed Phrase", 700, 500)
        
        # Warning
        warning_text = """⚠️ IMPORTANT: Write down your seed phrase and store it securely!

This is the ONLY way to recover your wallet if you lose access.
Never share your seed phrase with anyone."""
        
        warning_label = ttk.Label(dialog, text=warning_text, style="Light.TLabel", 
                                 wraplength=650, justify='center')
        warning_label.pack(pady=20, padx=20)
        
        # Seed phrase display
        seed_frame = ttk.LabelFrame(dialog, text="Your Seed Phrase", style="Dark.TLabelframe")
        seed_frame.pack(fill=tk.X, padx=20, pady=20)
        
        seed_text = tk.Text(seed_frame, height=4, width=60, wrap=tk.WORD,
                           bg=self.ui.colors['bg_secondary'], 
                           fg=self.ui.colors['text_primary'],
                           font=self.ui.fonts['mono'], relief='flat', borderwidth=10)
        seed_text.pack(padx=10, pady=10)
        seed_text.insert('1.0', mnemonic)
        seed_text.config(state='disabled')
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        copy_btn = self.ui.create_button(btn_frame, "📋 Copy to Clipboard", 
                                       lambda: self.copy_to_clipboard(mnemonic), "secondary")
        copy_btn.pack(side=tk.LEFT, padx=10)
        
        continue_btn = self.ui.create_button(btn_frame, "✅ I've Saved It", 
                                           lambda: self.complete_wallet_setup(dialog, wallet_id), "primary")
        continue_btn.pack(side=tk.LEFT, padx=10)
    
    def complete_wallet_setup(self, dialog, wallet_id):
        """Complete wallet setup and create first account"""
        dialog.destroy()
        
        # Unlock the wallet (it should already be unlocked from creation)
        self.is_locked = False
        self.current_wallet_id = wallet_id
        
        # Get seed phrase and create first account
        seed_phrase = self.storage_manager.get_seed_phrase(wallet_id)
        if seed_phrase:
            accounts = self.wallet_core.create_wallet_from_mnemonic(seed_phrase, "", 1)
            if accounts:
                # Store the account
                account_data = {
                    "name": "Account 1",
                    "address": accounts[0].address,
                    "private_key": accounts[0].private_key,
                    "derivation_path": accounts[0].derivation_path,
                    "account_index": accounts[0].account_index
                }
                
                self.storage_manager.store_account(wallet_id, account_data)
                self.current_account = account_data
                self.accounts = [account_data]
                
                # Update UI
                self.update_account_ui()
                self.create_top_bar(self.root.winfo_children()[0])  # Refresh top bar
                self.manual_refresh_balance()
                self.refresh_wallet_list()  # Refresh wallet list
                
                messagebox.showinfo("Success", "Wallet created successfully! You can now receive and send funds.")
                
                # Initialize network connection
                self.on_network_change()
        
    def import_wallet_dialog(self, parent_dialog=None):
        """Show import wallet dialog"""
        if parent_dialog:
            parent_dialog.destroy()
        
        dialog = self.ui.create_modal_dialog("Import Wallet", 600, 400)
        
        # Seed phrase input
        seed_group = self.ui.create_input_group(dialog, "Seed Phrase:", 
                                               "Enter your 12 or 24 word seed phrase", "textarea", 50)
        seed_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Password input
        password_group = self.ui.create_input_group(dialog, "Set Password:", 
                                                   "Enter password for this wallet", "password", 40)
        password_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Import button
        import_btn = self.ui.create_button(dialog, "📥 Import Wallet", 
                                         lambda: self.import_wallet(dialog, seed_group, password_group), 
                                         "primary")
        import_btn.pack(pady=20)
    
    def import_wallet(self, dialog, seed_group, password_group):
        """Import wallet from seed phrase"""
        seed_phrase = seed_group["input"].get('1.0', tk.END).strip()
        password = password_group["input"].get()
        
        if not seed_phrase:
            messagebox.showerror("Error", "Please enter a seed phrase!")
            return
        
        if len(password) < 8:
            messagebox.showerror("Error", "Password must be at least 8 characters!")
            return
        
        try:
            # Validate seed phrase
            if not self.wallet_core.validate_mnemonic(seed_phrase):
                messagebox.showerror("Error", "Invalid seed phrase!")
                return
            
            # Create wallet
            wallet_id = self.storage_manager.create_wallet("Imported Low Cap Charter Wallet", password, seed_phrase)
            
            if wallet_id:
                self.current_wallet_id = wallet_id
                
                # Create first few accounts
                accounts = self.wallet_core.create_wallet_from_mnemonic(seed_phrase, "", 3)
                
                account_list = []
                for i, account in enumerate(accounts):
                    account_data = {
                        "name": f"Account {i + 1}",
                        "address": account.address,
                        "private_key": account.private_key,
                        "derivation_path": account.derivation_path,
                        "account_index": account.account_index
                    }
                    self.storage_manager.store_account(wallet_id, account_data)
                    account_list.append(account_data)
                
                self.current_account = account_list[0] if account_list else None
                self.accounts = account_list
                self.is_locked = False
                
                dialog.destroy()
                self.update_account_ui()
                self.create_top_bar(self.root.winfo_children()[0])  # Refresh top bar
                self.manual_refresh_balance()
                self.refresh_wallet_list()  # Refresh wallet list
                
                messagebox.showinfo("Success", f"Wallet imported successfully! {len(account_list)} accounts created.")
                
                # Initialize network connection
                self.on_network_change()
                
            else:
                messagebox.showerror("Error", "Failed to import wallet!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to import wallet: {str(e)}")
    
    def unlock_wallet(self):
        """Unlock the wallet with password"""
        wallets = self.storage_manager.get_wallets()
        if not wallets:
            self.show_welcome_dialog()
            return
        
        dialog = self.ui.create_modal_dialog("Unlock Wallet", 400, 200)
        
        # Wallet selection
        wallet_var = tk.StringVar()
        wallet_combo = ttk.Combobox(dialog, textvariable=wallet_var, 
                                   values=[w["name"] for w in wallets], 
                                   state="readonly", width=30)
        wallet_combo.pack(pady=10)
        wallet_combo.set(wallets[0]["name"] if wallets else "")
        
        # Password input
        password_group = self.ui.create_input_group(dialog, "Password:", 
                                                   "Enter wallet password", "password", 30)
        password_group["frame"].pack(pady=10)
        
        # Unlock button
        unlock_btn = self.ui.create_button(dialog, "🔓 Unlock", 
                                         lambda: self.perform_unlock(dialog, wallet_var, password_group, wallets), 
                                         "primary")
        unlock_btn.pack(pady=10)
    
    def perform_unlock(self, dialog, wallet_var, password_group, wallets):
        """Perform wallet unlock"""
        wallet_name = wallet_var.get()
        password = password_group["input"].get()
        
        if not wallet_name or not password:
            messagebox.showerror("Error", "Please select wallet and enter password!")
            return
        
        # Find wallet
        wallet = next((w for w in wallets if w["name"] == wallet_name), None)
        if not wallet:
            messagebox.showerror("Error", "Wallet not found!")
            return
        
        try:
            if self.storage_manager.unlock_wallet(wallet["wallet_id"], password):
                # Load accounts
                accounts = self.storage_manager.get_accounts(wallet["wallet_id"])
                self.accounts = accounts
                self.current_account = accounts[0] if accounts else None
                self.current_wallet_id = wallet["wallet_id"]
                self.is_locked = False
                
                dialog.destroy()
                self.update_account_ui()
                self.create_top_bar(self.root.winfo_children()[0])  # Refresh top bar
                self.manual_refresh_balance()
                self.refresh_wallet_list()  # Refresh wallet list
                self.update_status("Wallet unlocked successfully")
                
                # Initialize network connection
                self.on_network_change()
                
            else:
                messagebox.showerror("Error", "Incorrect password!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to unlock wallet: {str(e)}")
    
    def lock_wallet(self):
        """Lock the wallet"""
        self.storage_manager.lock_wallet()
        self.is_locked = True
        self.current_account = None
        self.current_wallet_id = None
        self.accounts = []
        
        # Update UI
        self.create_top_bar(self.root.winfo_children()[0])
        self.update_status("Wallet locked")
        self.refresh_wallet_list()  # Refresh wallet list to update status
        
        # Clear sensitive data from UI
        self.balance_label.config(text="0.00 ETH")
        self.usd_balance_label.config(text="$0.00 USD")
        self.balance_status_label.config(text="")
        self.address_var.set("")
    
    def on_network_change(self, event=None):
        """Handle network change with connection testing"""
        network_name = self.network_var.get()
        network = self.network_manager.get_network(network_name)
        
        if not network:
            self.update_status(f"Network {network_name} not found!")
            return
        
        self.current_network = network
        
        # Test connection in background
        def test_and_switch():
            working_rpc = self.network_manager.get_working_rpc(network)
            if working_rpc:
                self.root.after(0, lambda: self.update_status(f"Switched to {network_name}"))
                self.root.after(0, self.manual_refresh_balance)
            else:
                self.root.after(0, lambda: self.update_status(f"Failed to connect to {network_name}"))
        
        threading.Thread(target=test_and_switch, daemon=True).start()
    
    def update_account_ui(self):
        """Update account-related UI elements - ENHANCED FOR MULTI-WALLET"""
        # Update address display
        if self.current_account:
            self.address_var.set(self.current_account['address'])
            # Also update receive tab address display immediately
            if hasattr(self, 'receive_address_label'):
                self.receive_address_label.config(text=self.current_account['address'])
        else:
            self.address_var.set("")
            if hasattr(self, 'receive_address_label'):
                self.receive_address_label.config(text="No account selected")
        
        # Update accounts tree (individual accounts)
        if hasattr(self, 'acc_tree'):
            # Clear existing items
            for item in self.acc_tree.get_children():
                self.acc_tree.delete(item)
            
            # Add accounts
            for account in self.accounts:
                balance_cache = account.get('balance_cache', {})
                current_network_name = self.network_var.get()
                cached_balance = balance_cache.get(current_network_name, {})
                balance_display = cached_balance.get('balance', 'Unknown')
                
                # Get wallet name for this account
                wallet_name = "Unknown"
                if self.current_wallet_id:
                    wallets = self.storage_manager.get_wallets()
                    current_wallet = next((w for w in wallets if w["wallet_id"] == self.current_wallet_id), None)
                    if current_wallet:
                        wallet_name = current_wallet["name"]
                
                # Status based on current account
                status = "Active" if account == self.current_account else "Available"
                
                self.acc_tree.insert("", "end", values=(
                    account['name'],
                    account['address'][:10] + "...",
                    balance_display,
                    wallet_name,
                    status
                ))
        
        # Update wallet tree
        self.refresh_wallet_list()
        
        # Update receive account combo
        if hasattr(self, 'receive_account_combo'):
            account_options = [f"{acc['name']} ({acc['address'][:10]}...)" for acc in self.accounts]
            self.receive_account_combo['values'] = account_options
            if account_options:
                self.receive_account_combo.set(account_options[0])
                self.update_receive_address()
    
    # =============================================================================
    # ACCOUNT MANAGEMENT METHODS - ENHANCED
    # =============================================================================
    
    def create_new_account(self):
        """Create new account from current wallet's seed"""
        if not self.current_wallet_id or self.is_locked:
            messagebox.showwarning("Warning", "Please unlock a wallet first!")
            return
        
        try:
            # Get current seed phrase
            seed_phrase = self.storage_manager.get_seed_phrase(self.current_wallet_id)
            if not seed_phrase:
                messagebox.showerror("Error", "Unable to access seed phrase!")
                return
            
            # Find next account index
            next_index = len(self.accounts)
            
            # Create new account
            accounts = self.wallet_core.create_wallet_from_mnemonic(seed_phrase, "", next_index + 1)
            if accounts and len(accounts) > next_index:
                new_account = accounts[next_index]
                
                account_data = {
                    "name": f"Account {next_index + 1}",
                    "address": new_account.address,
                    "private_key": new_account.private_key,
                    "derivation_path": new_account.derivation_path,
                    "account_index": new_account.account_index
                }
                
                # Store the account
                if self.storage_manager.store_account(self.current_wallet_id, account_data):
                    self.accounts.append(account_data)
                    self.update_account_ui()
                    
                    messagebox.showinfo("Success", f"Created new account: {account_data['name']}")
                else:
                    messagebox.showerror("Error", "Failed to store account!")
            else:
                messagebox.showerror("Error", "Failed to create account!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to create account: {str(e)}")
    
    def import_account(self):
        """Import account from private key"""
        if not self.current_wallet_id or self.is_locked:
            messagebox.showwarning("Warning", "Please unlock a wallet first!")
            return
        
        dialog = self.ui.create_modal_dialog("Import Account from Private Key", 500, 300)
        
        # Account name
        name_group = self.ui.create_input_group(dialog, "Account Name:", 
                                               "Enter account name", "text", 30)
        name_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Private key
        key_group = self.ui.create_input_group(dialog, "Private Key:", 
                                              "Enter private key (with or without 0x)", "password", 50)
        key_group["frame"].pack(fill=tk.X, padx=20, pady=10)
        
        # Buttons
        btn_frame = ttk.Frame(dialog, style="Dark.TFrame")
        btn_frame.pack(pady=20)
        
        import_btn = self.ui.create_button(btn_frame, "📥 Import Account", 
                                         lambda: self.perform_account_import(dialog, name_group, key_group), 
                                         "primary")
        import_btn.pack(side=tk.LEFT, padx=10)
        
        cancel_btn = self.ui.create_button(btn_frame, "❌ Cancel", 
                                         lambda: dialog.destroy(), "secondary")
        cancel_btn.pack(side=tk.LEFT, padx=10)
    
    def perform_account_import(self, dialog, name_group, key_group):
        """Perform account import from private key"""
        account_name = name_group["input"].get()
        private_key = key_group["input"].get()
        
        if not account_name or not private_key:
            messagebox.showerror("Error", "Please enter both account name and private key!")
            return
        
        try:
            # Import account using wallet core
            imported_account = self.wallet_core.import_from_private_key(private_key, account_name)
            
            account_data = {
                "name": imported_account.name,
                "address": imported_account.address,
                "private_key": imported_account.private_key,
                "derivation_path": imported_account.derivation_path,
                "account_index": imported_account.account_index
            }
            
            # Store the account
            if self.storage_manager.store_account(self.current_wallet_id, account_data):
                self.accounts.append(account_data)
                self.update_account_ui()
                
                dialog.destroy()
                messagebox.showinfo("Success", f"Imported account: {account_name}")
            else:
                messagebox.showerror("Error", "Failed to store imported account!")
                
        except Exception as e:
            messagebox.showerror("Error", f"Failed to import account: {str(e)}")
    
    def switch_active_account(self):
        """Switch to selected account"""
        if not self.accounts:
            messagebox.showwarning("Warning", "No accounts available!")
            return
        
        selection = self.acc_tree.selection()
        if not selection:
            messagebox.showwarning("Warning", "Please select an account first!")
            return
        
        # Get selected account info
        item = self.acc_tree.item(selection[0])
        values = item['values']
        account_name = values[0]
        
        # Find the account
        selected_account = next((acc for acc in self.accounts if acc['name'] == account_name), None)
        
        if selected_account:
            self.current_account = selected_account
            self.update_account_ui()
            self.manual_refresh_balance()
            
            messagebox.showinfo("Success", f"Switched to account: {account_name}")
        else:
            messagebox.showerror("Error", "Account not found!")
    
    # =============================================================================
    # ADDITIONAL METHODS FOR ENHANCED FUNCTIONALITY
    # =============================================================================
    
    def view_transaction_history(self):
        """View detailed transaction history"""
        if not self.current_account or not self.current_network:
            messagebox.showwarning("Warning", "No account or network selected!")
            return
        
        messagebox.showinfo("Transaction History", "Loading transaction history...")
        
        def load_history():
            try:
                transactions = self.transaction_manager.get_transaction_history(
                    self.current_account['address'],
                    self.current_network,
                    limit=100
                )
                
                if transactions:
                    self.root.after(0, lambda: self.display_transaction_history(transactions))
                else:
                    self.root.after(0, lambda: messagebox.showinfo("Transaction History", "No transactions found"))
                    
            except Exception as e:
                self.root.after(0, lambda: messagebox.showerror("Error", f"Failed to load transaction history: {str(e)}"))
        
        threading.Thread(target=load_history, daemon=True).start()
    
    def display_transaction_history(self, transactions):
        """Display transaction history in a new window"""
        history_window = tk.Toplevel(self.root)
        history_window.title("Transaction History")
        history_window.geometry("800x600")
        history_window.configure(bg=self.ui.colors['bg_primary'])
        
        # Create treeview for transactions
        columns = ("Date", "Type", "Amount", "Address", "Hash", "Status")
        tree = ttk.Treeview(history_window, columns=columns, show="headings", style="Dark.Treeview")
        
        for col in columns:
            tree.heading(col, text=col)
            tree.column(col, width=120)
        
        scrollbar = ttk.Scrollbar(history_window, orient=tk.VERTICAL, command=tree.yview)
        tree.configure(yscrollcommand=scrollbar.set)
        
        # Add transactions
        for tx in transactions:
            try:
                date_str = time.strftime('%Y-%m-%d %H:%M', time.localtime(tx['timestamp']))
                tree.insert("", "end", values=(
                    date_str,
                    tx['type'],
                    tx['value_eth'],
                    tx['to'][:20] + "..." if tx['to'] else "Contract",
                    tx['hash'][:20] + "...",
                    "Confirmed"
                ))
            except Exception as e:
                print(f"Error adding transaction to tree: {e}")
        
        tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=10, pady=10)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y, pady=10)
    
    def refresh_transaction_history(self):
        """Refresh transaction history in the main tab"""
        if not self.current_account or not self.current_network:
            return
        
        def load_recent_transactions():
            try:
                transactions = self.transaction_manager.get_transaction_history(
                    self.current_account['address'],
                    self.current_network,
                    limit=10  # Just recent transactions for main tab
                )
                
                self.root.after(0, lambda: self.update_transaction_tree(transactions))
                
            except Exception as e:
                print(f"Failed to load transactions: {e}")
        
        threading.Thread(target=load_recent_transactions, daemon=True).start()
    
    def update_transaction_tree(self, transactions):
        """Update transaction tree with new data"""
        # Clear existing items
        for item in self.tx_tree.get_children():
            self.tx_tree.delete(item)
        
        # Add new transactions
        for tx in transactions:
            try:
                date_str = time.strftime('%m-%d %H:%M', time.localtime(tx['timestamp']))
                self.tx_tree.insert("", "end", values=(
                    date_str,
                    tx['type'].title(),
                    f"{tx['value_eth']} ETH",
                    tx['to'][:15] + "..." if tx['to'] else "Contract",
                    "Confirmed",
                    tx['hash'][:15] + "..."
                ))
            except Exception as e:
                print(f"Error adding transaction: {e}")
    
    def view_transaction_details(self, event):
        """View detailed transaction information"""
        selection = self.tx_tree.selection()
        if not selection:
            return
        
        item = self.tx_tree.item(selection[0])
        values = item['values']
        
        if len(values) >= 6:
            tx_hash = values[5].replace("...", "")  # This is simplified - you'd need to store full hash
            messagebox.showinfo("Transaction Details", f"Transaction Hash: {tx_hash}\n\nDetailed view will be implemented")
    
    def test_all_networks(self):
        """Test connectivity to all networks"""
        self.update_status("Testing all networks...")
        
        def test_networks():
            try:
                report = self.network_manager.get_network_health_report()
                
                message = f"Network Health Report:\n"
                message += f"Total Networks: {report['total_networks']}\n"
                message += f"Healthy Networks: {report['healthy_networks']}\n"
                message += f"Unhealthy Networks: {report['unhealthy_networks']}\n\n"
                
                message += "Network Details:\n"
                for name, details in report['network_details'].items():
                    health_pct = details['health_percentage']
                    message += f"• {name}: {health_pct:.0f}% healthy\n"
                
                self.root.after(0, lambda: messagebox.showinfo("Network Health Report", message))
                self.root.after(0, lambda: self.update_status("Network testing completed"))
                
            except Exception as e:
                self.root.after(0, lambda: messagebox.showerror("Error", f"Network testing failed: {str(e)}"))
        
        threading.Thread(target=test_networks, daemon=True).start()
    
    def optimize_network_rpcs(self):
        """Optimize RPC endpoints for better performance"""
        self.update_status("Optimizing network RPCs...")
        
        def optimize():
            try:
                results = self.network_manager.auto_optimize_rpcs()
                
                message = "RPC Optimization Results:\n\n"
                for network, rpcs in results.items():
                    message += f"{network}: {len(rpcs)} optimized RPCs\n"
                
                self.root.after(0, lambda: messagebox.showinfo("RPC Optimization", message))
                self.root.after(0, lambda: self.update_status("RPC optimization completed"))
                
            except Exception as e:
                self.root.after(0, lambda: messagebox.showerror("Error", f"RPC optimization failed: {str(e)}"))
        
        threading.Thread(target=optimize, daemon=True).start()
    
    def copy_to_clipboard(self, text):
        """Copy text to clipboard"""
        self.root.clipboard_clear()
        self.root.clipboard_append(text)
        self.update_status("Copied to clipboard")
    
    def update_status(self, message):
        """Update status bar message"""
        self.status_label.config(text=message)
        self.last_update_label.config(text=f"Last update: {time.strftime('%H:%M:%S')}")
        self.root.after(5000, lambda: self.status_label.config(text="Ready"))
    
    # =============================================================================
    # PLACEHOLDER METHODS FOR FEATURES TO BE IMPLEMENTED
    # =============================================================================
    
    def apply_settings(self):
        """Apply application settings"""
        try:
            interval = int(self.refresh_interval_var.get())
            if interval < 5:
                messagebox.showwarning("Warning", "Refresh interval must be at least 5 seconds")
                return
            
            messagebox.showinfo("Settings", "Settings applied successfully!")
            self.update_status("Settings updated")
            
        except ValueError:
            messagebox.showerror("Error", "Invalid refresh interval")
    
    def export_account(self):
        """Export account details securely"""
        if not self.current_account or self.is_locked:
            messagebox.showwarning("Warning", "Please select an account first!")
            return
        
        # Get selected account from tree if different from current
        selection = self.acc_tree.selection()
        if selection:
            item = self.acc_tree.item(selection[0])
            values = item['values']
            account_name = values[0]
            selected_account = next((acc for acc in self.accounts if acc['name'] == account_name), None)
        else:
            selected_account = self.current_account
        
        if not selected_account:
            messagebox.showwarning("Warning", "No account selected!")
            return
        
        # Show export options dialog
        dialog = self.ui.create_modal_dialog("Export Account", 400, 300)
        
        info_text = f"""Export Account: {selected_account['name']}
Address: {selected_account['address'][:20]}...

Choose what to export:"""
        
        info_label = ttk.Label(dialog, text=info_text, style="Light.TLabel", 
                              wraplength=350, justify='left')
        info_label.pack(pady=20, padx=20)
        
        # Export options
        options_frame = ttk.Frame(dialog, style="Dark.TFrame")
        options_frame.pack(pady=10)
        
        export_address_btn = self.ui.create_button(options_frame, "📋 Copy Address Only", 
                                                  lambda: self.export_address_only(dialog, selected_account), 
                                                  "secondary")
        export_address_btn.pack(pady=5, fill=tk.X, padx=20)
        
        export_private_key_btn = self.ui.create_button(options_frame, "🔑 Export Private Key", 
                                                      lambda: self.export_with_private_key(dialog, selected_account), 
                                                      "accent")
        export_private_key_btn.pack(pady=5, fill=tk.X, padx=20)
        
        cancel_btn = self.ui.create_button(options_frame, "❌ Cancel", 
                                         lambda: dialog.destroy(), "secondary")
        cancel_btn.pack(pady=10, fill=tk.X, padx=20)
    
    def export_address_only(self, dialog, account):
        """Export only the address (safe option)"""
        self.copy_to_clipboard(account['address'])
        dialog.destroy()
        messagebox.showinfo("Exported", f"Address copied to clipboard:\n{account['address']}")
    
    def export_with_private_key(self, dialog, account):
        """Export account with private key (requires password)"""
        dialog.destroy()
        
        # Show security warning and get password
        self.view_account_private_key()  # Reuse the existing secure private key viewing
    
    def on_account_select(self, event):
        """Handle account selection"""
        pass
    
    def refresh_all_account_balances(self):
        """Refresh balances for all accounts"""
        messagebox.showinfo("Feature", "Bulk balance refresh will be implemented")
    
    def add_custom_network(self):
        """Add custom network"""
        messagebox.showinfo("Feature", "Custom network addition will be implemented")
    
    def change_password(self):
        """Change wallet password"""
        messagebox.showinfo("Feature", "Password change will be implemented")
    
    def backup_wallet(self):
        """Backup wallet to file"""
        messagebox.showinfo("Feature", "Wallet backup will be implemented")
    
    def update_gas_estimate(self, event=None):
        """Update gas estimate based on speed selection"""
        pass
    
    def run(self):
        """Start the wallet application"""
        self.root.mainloop()

# Backward compatibility
CryptoWallet = ImprovedCryptoWallet

if __name__ == "__main__":
    try:
        wallet = ImprovedCryptoWallet()
        wallet.run()
    except Exception as e:
        print(f"Failed to start wallet: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)