Update app.py

app.py

@@ -1,108 +1,210 @@
-###############################################################################
-#                               IMPORTS & CONSTANTS                              #
-###############################################################################
+"""
+Blockchain Wallet Analyzer - A tool for analyzing Ethereum wallet contents and NFT holdings.
+
+This module provides a complete implementation of a blockchain wallet analysis tool
+with a Gradio web interface. It includes wallet analysis, NFT tracking, and 
+interactive chat capabilities using the OpenAI API.
+
+Author: Claude
+Date: January 2025
+"""
+
+from __future__ import annotations
 
 import os
 import re
-import aiohttp
+import json
+import time
+import logging
 import asyncio
-import openai
+from typing import List, Dict, Tuple, Any, Optional, TypeVar, cast
 from datetime import datetime
-from typing import List, Dict, Tuple, Any, Optional
 from decimal import Decimal
-import time
-import json
-import gradio as gr
-
-SYSTEM_PROMPT: str = """
-You are LOSS DOG 🐕 (Learning & Observing Smart Systems Digital Output Generator), an adorable blockchain-sniffing puppy!
-Your personality:
-- Friendly and enthusiastic
-- Explain findings in fun, simple ways
-
-Instructions:
-- You have access to detailed wallet data in your context
-- Use this data to provide specific answers about holdings
-- Reference exact numbers and collections when discussing NFTs
-- Compare wallets if multiple are available
-"""
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
 
-ETHERSCAN_BASE_URL: str = "https://api.etherscan.io/api"
-ETHEREUM_ADDRESS_REGEX: str = r"0x[a-fA-F0-9]{40}"
-
-###############################################################################
-#                           ETHERSCAN CLIENT CLASS                              #
-###############################################################################
+import aiohttp
+import openai
+import gradio as gr
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+# Type variables
+T = TypeVar('T')
+WalletData = Dict[str, Any]
+ChatHistory = List[Tuple[str, str]]
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('blockchain_analyzer.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class ConfigError(Exception):
+    """Raised when there's an error in configuration."""
+    pass
+
+class APIError(Exception):
+    """Raised when there's an error in API calls."""
+    pass
+
+class ValidationError(Exception):
+    """Raised when there's an error in input validation."""
+    pass
+
+@dataclass
+class Config:
+    """Application configuration settings."""
+    SYSTEM_PROMPT: str = """
+    You are LOSS DOG 🐕 (Learning & Observing Smart Systems Digital Output Generator), 
+    an adorable blockchain-sniffing puppy!
+    Your personality:
+    - Friendly and enthusiastic
+    - Explain findings in fun, simple ways
+
+    Instructions:
+    - You have access to detailed wallet data in your context
+    - Use this data to provide specific answers about holdings
+    - Reference exact numbers and collections when discussing NFTs
+    - Compare wallets if multiple are available
+    """
+    ETHERSCAN_BASE_URL: str = "https://api.etherscan.io/api"
+    ETHEREUM_ADDRESS_REGEX: str = r"0x[a-fA-F0-9]{40}"
+    RATE_LIMIT_DELAY: float = 0.2  # 5 requests per second max for free tier
+    MAX_RETRIES: int = 3
+    OPENAI_MODEL: str = "gpt-4o-mini"  # Updated to correct model name
+    MAX_TOKENS: int = 4000
+    TEMPERATURE: float = 0.7
+    HISTORY_LIMIT: int = 5
+
+    @classmethod
+    def load(cls, config_path: str | Path) -> Config:
+        """Load configuration from a JSON file."""
+        try:
+            with open(config_path) as f:
+                config_data = json.load(f)
+                return cls(**config_data)
+        except Exception as e:
+            logger.error(f"Error loading config: {e}")
+            return cls()
 
-class EtherscanClient:
+class WalletAnalyzer:
+    """Analyzes Ethereum wallet contents using Etherscan API."""
+    
     def __init__(self, api_key: str):
+        """Initialize the analyzer with API key."""
         self.api_key = api_key
-        self.base_url = ETHERSCAN_BASE_URL
+        self.base_url = Config.ETHERSCAN_BASE_URL
         self.last_request_time = 0
-        self.rate_limit_delay = 0.2  # 5 requests per second max for free tier
+        self.session: Optional[aiohttp.ClientSession] = None
+    
+    async def __aenter__(self) -> WalletAnalyzer:
+        """Create aiohttp session on context manager enter."""
+        self.session = aiohttp.ClientSession()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Close aiohttp session on context manager exit."""
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+    @retry(
+        stop=stop_after_attempt(Config.MAX_RETRIES),
+        wait=wait_exponential(multiplier=1, min=4, max=10)
+    )
+    async def _fetch_data(self, params: Dict[str, str]) -> Dict[str, Any]:
+        """Fetch data from Etherscan API with retry logic."""
+        if not self.session:
+            raise APIError("No active session. Use context manager.")
+            
+        await self._rate_limit()
+        params["apikey"] = self.api_key
+        
+        try:
+            async with self.session.get(self.base_url, params=params) as response:
+                if response.status != 200:
+                    raise APIError(f"API request failed: {response.status}")
+                
+                data = await response.json()
+                if data["status"] == "0":
+                    error_msg = data.get('message', 'Unknown error')
+                    if "Max rate limit reached" in error_msg:
+                        raise APIError("Rate limit exceeded")
+                    raise APIError(f"API error: {error_msg}")
+                    
+                return data
+                
+        except aiohttp.ClientError as e:
+            raise APIError(f"Network error: {str(e)}")
+        except Exception as e:
+            raise APIError(f"Unexpected error: {str(e)}")
 
-    async def _rate_limit(self):
-        """Implement rate limiting for Etherscan API"""
+    async def _rate_limit(self) -> None:
+        """Implement rate limiting for Etherscan API."""
         current_time = time.time()
         time_passed = current_time - self.last_request_time
-        if time_passed < self.rate_limit_delay:
-            await asyncio.sleep(self.rate_limit_delay - time_passed)
+        if time_passed < Config.RATE_LIMIT_DELAY:
+            await asyncio.sleep(Config.RATE_LIMIT_DELAY - time_passed)
         self.last_request_time = time.time()
 
-    async def fetch_data(self, params: Dict[str, str]) -> Dict[str, Any]:
-        """Generic method to fetch data from Etherscan API"""
-        params["apikey"] = self.api_key
-        await self._rate_limit()
-        
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(self.base_url, params=params) as response:
-                    if response.status != 200:
-                        return {"error": f"API request failed: {response.status}"}
-                    data = await response.json()
-                    if data["status"] == "0":
-                        error_msg = data.get('message', 'Unknown error')
-                        if "Max rate limit reached" in error_msg:
-                            await asyncio.sleep(1)
-                            return await self.fetch_data(params)
-                        return {"error": f"API error: {error_msg}"}
-                    return data
-        except Exception as e:
-            return {"error": f"Error fetching data: {str(e)}"}
+    @staticmethod
+    def _validate_address(address: str) -> bool:
+        """Validate Ethereum address format."""
+        return bool(re.match(Config.ETHEREUM_ADDRESS_REGEX, address))
+
+    async def get_portfolio_data(self, address: str) -> WalletData:
+        """Get complete portfolio including ETH, tokens, and NFTs."""
+        if not self._validate_address(address):
+            raise ValidationError(f"Invalid Ethereum address: {address}")
 
-    async def get_portfolio_data(self, address: str) -> Dict[str, Any]:
-        """Get complete portfolio including ETH, tokens, and NFTs"""
+        logger.info(f"Fetching portfolio data for {address}")
+        
         # Get ETH balance
-        eth_params = {
+        eth_balance = await self._get_eth_balance(address)
+        
+        # Get token data
+        token_holdings = await self._get_token_holdings(address)
+        
+        # Get NFT data
+        nft_collections = await self._get_nft_holdings(address)
+        
+        return {
+            "address": address,
+            "last_updated": datetime.now().isoformat(),
+            "eth_balance": float(eth_balance),
+            "tokens": token_holdings,
+            "nft_collections": nft_collections
+        }
+
+    async def _get_eth_balance(self, address: str) -> Decimal:
+        """Get ETH balance for address."""
+        params = {
             "module": "account",
             "action": "balance",
             "address": address,
             "tag": "latest"
         }
-        eth_data = await self.fetch_data(eth_params)
-        eth_balance = Decimal(eth_data.get("result", "0")) / Decimal("1000000000000000000")
+        data = await self._fetch_data(params)
+        return Decimal(data["result"]) / Decimal("1000000000000000000")
 
-        # Get token transfers
-        token_params = {
+    async def _get_token_holdings(self, address: str) -> List[Dict[str, Any]]:
+        """Get token holdings for address."""
+        params = {
             "module": "account",
             "action": "tokentx",
             "address": address,
             "sort": "desc"
         }
-        token_data = await self.fetch_data(token_params)
-        
-        # Get NFTs
-        nft_params = {
-            "module": "account",
-            "action": "tokennfttx",
-            "address": address,
-            "sort": "desc"
-        }
-        nft_data = await self.fetch_data(nft_params)
+        data = await self._fetch_data(params)
         
-        # Process token holdings
-        token_holdings = {}
-        for tx in token_data.get("result", []):
+        token_holdings: Dict[str, Dict[str, Any]] = {}
+        for tx in data.get("result", []):
             contract = tx["contractAddress"]
             if contract not in token_holdings:
                 token_holdings[contract] = {
@@ -118,9 +220,30 @@ class EtherscanClient:
             elif tx["from"].lower() == address.lower():
                 token_holdings[contract]["balance"] -= amount
 
-        # Process NFTs
-        nft_holdings = {}
-        for tx in nft_data.get("result", []):
+        return [
+            {
+                "name": data["name"],
+                "symbol": data["symbol"],
+                "balance": float(data["balance"])
+            }
+            for data in token_holdings.values()
+            if data["balance"] > 0
+        ]
+
+    async def _get_nft_holdings(self, address: str) -> Dict[str, Dict[str, Any]]:
+        """Get NFT holdings for address."""
+        params = {
+            "module": "account",
+            "action": "tokennfttx",
+            "address": address,
+            "sort": "desc"
+        }
+        data = await self._fetch_data(params)
+        
+        nft_holdings: Dict[str, Dict[str, Any]] = {}
+        collections: Dict[str, List[str]] = {}
+        
+        for tx in data.get("result", []):
             collection_name = tx.get("tokenName", "Unknown Collection")
             token_id = tx["tokenID"]
             key = f"{tx['contractAddress']}_{token_id}"
@@ -132,335 +255,350 @@ class EtherscanClient:
                     "contract": tx["contractAddress"],
                     "acquired_time": tx["timeStamp"]
                 }
+                
+                if collection_name not in collections:
+                    collections[collection_name] = []
+                collections[collection_name].append(token_id)
+                
             elif tx["from"].lower() == address.lower():
                 nft_holdings.pop(key, None)
-
-        # Organize NFTs by collection
-        collections = {}
-        for nft in nft_holdings.values():
-            coll = nft["collection"]
-            if coll not in collections:
-                collections[coll] = []
-            collections[coll].append(nft["token_id"])
+                if collection_name in collections and token_id in collections[collection_name]:
+                    collections[collection_name].remove(token_id)
 
         return {
-            "address": address,
-            "last_updated": datetime.now().isoformat(),
-            "eth_balance": float(eth_balance),
-            "tokens": [
-                {
-                    "name": data["name"],
-                    "symbol": data["symbol"],
-                    "balance": float(data["balance"])
-                }
-                for data in token_holdings.values()
-                if data["balance"] > 0
-            ],
-            "nft_collections": {
-                name: {
-                    "count": len(tokens),
-                    "token_ids": tokens
-                }
-                for name, tokens in collections.items()
+            name: {
+                "count": len(tokens),
+                "token_ids": tokens
             }
+            for name, tokens in collections.items()
+            if tokens  # Only include collections with tokens
         }
 
-###############################################################################
-#                              HELPER FUNCTIONS                                 #
-###############################################################################
 
-def validate_openai_key(api_key: str) -> Tuple[bool, str]:
-    """Validate OpenAI API key by making a minimal API request."""
-    if not api_key:
-        return False, "OpenAI API key is required!"
-    try:
-        client = openai.OpenAI(api_key=api_key)
-        client.chat.completions.create(
-            model="gpt-4o-mini",  # Using the correct model name
-            messages=[{"role": "user", "content": "test"}],
-            max_tokens=4000
-        )
-        return True, "OpenAI API key is valid! 🎉"
-    except Exception as e:
-        return False, f"OpenAI API key validation failed: {str(e)}"
-
-def validate_etherscan_key(api_key: str) -> Tuple[bool, str]:
-    """Validate Etherscan API key by checking the API."""
-    if not api_key:
-        return False, "Etherscan API key is required!"
-    
-    async def validate():
-        client = EtherscanClient(api_key)
-        params = {"module": "stats", "action": "ethsupply"}
-        result = await client.fetch_data(params)
-        return "error" not in result
+class ChatInterface:
+    """Handles chat interaction using OpenAI API."""
     
-    try:
-        result = asyncio.run(validate())
-        return (True, "Etherscan API key is valid! 🎉") if result else (False, "Invalid Etherscan API key")
-    except Exception as e:
-        return False, f"Etherscan API key validation failed: {str(e)}"
-
-###############################################################################
-#                           MESSAGE PROCESSING                                  #
-###############################################################################
-
-async def process_message(
-    message: str,
-    openai_key: str,
-    etherscan_key: str,
-    history: List[Tuple[str, str]],
-    context: Dict[str, Any]
-) -> Tuple[List[Tuple[str, str]], Dict[str, Any], str]:
-    """Process user input and generate responses using wallet context."""
-    if not message.strip():
-        return history, context, ""
-
-    # Check for Ethereum address
-    match = re.search(ETHEREUM_ADDRESS_REGEX, message)
-    if match:
-        address = match.group(0)
-        client = EtherscanClient(etherscan_key)
-        
+    def __init__(self, openai_key: str, etherscan_key: str):
+        """Initialize chat interface with API keys."""
+        self.openai_key = openai_key
+        self.etherscan_key = etherscan_key
+        self.context: Dict[str, Any] = {}
+        openai.api_key = openai_key
+
+    @staticmethod
+    def _validate_api_keys(openai_key: str, etherscan_key: str) -> Tuple[bool, str]:
+        """Validate both API keys."""
         try:
-            wallet_data = await client.get_portfolio_data(address)
-            context[address] = wallet_data
+            # Validate OpenAI key
+            client = openai.OpenAI(api_key=openai_key)
+            client.chat.completions.create(
+                model=Config.OPENAI_MODEL,
+                messages=[{"role": "user", "content": "test"}],
+                max_tokens=1
+            )
             
-            # Create summary
-            summary = []
-            summary.append(f"📊 Portfolio Summary for {address[:8]}...{address[-6:]}")
-            summary.append(f"💎 ETH Balance: {wallet_data['eth_balance']:.4f} ETH")
-            summary.append(f"🪙 Tokens: {len(wallet_data['tokens'])} different tokens")
-            total_nfts = sum(coll['count'] for coll in wallet_data['nft_collections'].values())
-            summary.append(f"🎨 NFTs: {total_nfts} NFTs in {len(wallet_data['nft_collections'])} collections")
+            # Validate Etherscan key
+            async def validate_etherscan():
+                async with WalletAnalyzer(etherscan_key) as analyzer:
+                    params = {"module": "stats", "action": "ethsupply"}
+                    await analyzer._fetch_data(params)
             
-            bot_message = "\n".join(summary)
-            history.append((message, bot_message))
-            return history, context, ""
+            asyncio.run(validate_etherscan())
+            return True, "Both API keys are valid! 🎉"
             
         except Exception as e:
-            error_message = f"Error analyzing wallet: {str(e)}"
-            history.append((message, error_message))
-            return history, context, ""
+            return False, f"API key validation failed: {str(e)}"
 
-    # Generate response using OpenAI with context
-    try:
-        # Create context message from wallet data
-        context_msg = "Current Wallet Data:\n\n" if context else ""
-        for addr, data in context.items():
-            context_msg += f"Wallet {addr[:8]}...{addr[-6:]}:\n"
-            context_msg += f"- ETH Balance: {data['eth_balance']:.4f} ETH\n"
-            context_msg += f"- Tokens: {len(data['tokens'])}\n"
+    def _format_context_message(self) -> str:
+        """Format wallet data as context message."""
+        if not self.context:
+            return ""
+            
+        context_msg = ["Current Wallet Data:\n"]
+        for addr, data in self.context.items():
+            context_msg.extend([
+                f"Wallet {addr[:8]}...{addr[-6:]}:",
+                f"- ETH Balance: {data['eth_balance']:.4f} ETH",
+                f"- Tokens: {len(data['tokens'])}"
+            ])
             
             if data['tokens']:
-                context_msg += "  Token Holdings:\n"
+                context_msg.append("  Token Holdings:")
                 for token in data['tokens']:
-                    context_msg += f"  * {token['name']} ({token['symbol']}): {token['balance']}\n"
+                    context_msg.append(
+                        f"  * {token['name']} ({token['symbol']}): {token['balance']}"
+                    )
             
             if data['nft_collections']:
-                context_msg += "  NFT Collections:\n"
+                context_msg.append("  NFT Collections:")
                 for name, info in data['nft_collections'].items():
-                    context_msg += f"  * {name}: {info['count']} NFTs\n"
-                    if info['count'] <= 5:  # Show token IDs for small collections
-                        context_msg += f"    Token IDs: {', '.join(info['token_ids'])}\n"
-            context_msg += "\n"
-
-        # Convert history to OpenAI format
-        chat_history = []
-        for user_msg, assistant_msg in history[-5:]:
-            chat_history.extend([
-                {"role": "user", "content": user_msg},
-                {"role": "assistant", "content": assistant_msg}
-            ])
-
-        client = openai.OpenAI(api_key=openai_key)
-        response = client.chat.completions.create(
-            model="gpt-4o-mini",  # Using the correct model name
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "system", "content": context_msg},
-                *chat_history,
-                {"role": "user", "content": message}
-            ],
-            temperature=0.7,
-            max_tokens=4000
-        )
+                    context_msg.append(f"  * {name}: {info['count']} NFTs")
+                    if info['count'] <= 5:
+                        context_msg.append(
+                            f"    Token IDs: {', '.join(map(str, info['token_ids']))}"
+                        )
+                        
+        return "\n".join(context_msg)
+
+    async def process_message(
+        self,
+        message: str,
+        history: Optional[ChatHistory] = None
+    ) -> Tuple[ChatHistory, Dict[str, Any], str]:
+        """Process user message and generate response."""
+        if not message.strip():
+            return history or [], self.context, ""
+
+        history = history or []
         
-        bot_message = response.choices[0].message.content
-        history.append((message, bot_message))
-        return history, context, ""
-    except Exception as e:
-        error_message = f"Error generating response: {str(e)}"
-        history.append((message, error_message))
-        return history, context, ""
-
-###############################################################################
-#                              GRADIO INTERFACE                                #
-###############################################################################
-def create_interface() -> gr.Blocks:
-    """Create the Gradio interface."""
-    with gr.Blocks(theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 🐕 LOSS DOG: Blockchain Wallet Analyzer
-        
-        Welcome to LOSS DOG - Your friendly blockchain analysis companion!
-        - Enter your API keys below to get started
-        - Input an Ethereum wallet address to analyze
-        - Chat about your wallet contents with context!
-        """)
-
-        # API Keys Section
-        with gr.Row():
-            with gr.Column():
-                openai_key = gr.Textbox(
-                    label="OpenAI API Key",
-                    type="password",
-                    placeholder="Enter your OpenAI API key..."
-                )
-            with gr.Column():
-                etherscan_key = gr.Textbox(
-                    label="Etherscan API Key",
-                    type="password",
-                    placeholder="Enter your Etherscan API key..."
-                )
-
-        validation_status = gr.Textbox(
-            label="Validation Status",
-            interactive=False
-        )
-        validate_btn = gr.Button("Validate API Keys", variant="primary")
-
-        # Main Interface
-        with gr.Row():
-            # Chat Area (Left Side)
-            with gr.Column(scale=2):
-                chatbot = gr.Chatbot(
-                    label="Chat History",
-                    value=[],
-                    height=500,
-                    type="messages"  # Explicitly set message type
-                )
-                with gr.Row():
-                    msg_input = gr.Textbox(
-                        label="Message",
-                        placeholder="Enter wallet address or ask about holdings...",
-                        show_label=True
+        # Check for Ethereum address
+        match = re.search(Config.ETHEREUM_ADDRESS_REGEX, message)
+        if match:
+            try:
+                address = match.group(0)
+                async with WalletAnalyzer(self.etherscan_key) as analyzer:
+                    wallet_data = await analyzer.get_portfolio_data(address)
+                    self.context[address] = wallet_data
+                    
+                    summary = [
+                        f"📊 Portfolio Summary for {address[:8]}...{address[-6:]}",
+                        f"💎 ETH Balance: {wallet_data['eth_balance']:.4f} ETH",
+                        f"🪙 Tokens: {len(wallet_data['tokens'])} different tokens"
+                    ]
+                    
+                    total_nfts = sum(
+                        coll['count'] for coll in wallet_data['nft_collections'].values())
+                    
+                    summary.append(
+                        f"🎨 NFTs: {total_nfts} NFTs in {len(wallet_data['nft_collections'])} collections"
                     )
-                    send_btn = gr.Button("Send", variant="primary")
-
-            # Context Sidebar (Right Side)
-            with gr.Column(scale=1):
-                wallet_context = gr.JSON(
-                    label="Active Wallet Context",
-                    show_label=True,
-                    value={}
-                )
-                clear_btn = gr.Button("Clear Context", variant="secondary")
+                    
+                    bot_message = "\n".join(summary)
+                    history.append((message, bot_message))
+                    return history, self.context, ""
+                    
+            except Exception as e:
+                logger.error(f"Error analyzing wallet: {e}")
+                error_message = f"Error analyzing wallet: {str(e)}"
+                history.append((message, error_message))
+                return history, self.context, ""
+
+        # Generate response using OpenAI
+        try:
+            # Format context message
+            context_msg = self._format_context_message()
+            
+            # Convert history to OpenAI format
+            chat_history = []
+            for user_msg, assistant_msg in history[-Config.HISTORY_LIMIT:]:
+                chat_history.extend([
+                    {"role": "user", "content": user_msg},
+                    {"role": "assistant", "content": assistant_msg}
+                ])
+
+            # Create OpenAI client and generate response
+            client = openai.OpenAI(api_key=self.openai_key)
+            response = client.chat.completions.create(
+                model=Config.OPENAI_MODEL,
+                messages=[
+                    {"role": "system", "content": Config.SYSTEM_PROMPT},
+                    {"role": "system", "content": context_msg},
+                    *chat_history,
+                    {"role": "user", "content": message}
+                ],
+                temperature=Config.TEMPERATURE,
+                max_tokens=Config.MAX_TOKENS
+            )
+            
+            bot_message = response.choices[0].message.content
+            history.append((message, bot_message))
+            return history, self.context, ""
+            
+        except Exception as e:
+            logger.error(f"Error generating response: {e}")
+            error_message = f"Error generating response: {str(e)}"
+            history.append((message, error_message))
+            return history, self.context, ""
+
+    def clear_context(self) -> Tuple[Dict[str, Any], List[Tuple[str, str]]]:
+        """Clear the wallet context and chat history."""
+        self.context = {}
+        return {}, []
 
-        # Initial States
-        msg_input.interactive = False
-        send_btn.interactive = False
 
-        def validate_keys(openai_k: str, etherscan_k: str) -> Tuple[str, gr.update, gr.update]:
-            """Validate API keys."""
-            openai_valid, openai_msg = validate_openai_key(openai_k)
-            etherscan_valid, etherscan_msg = validate_etherscan_key(etherscan_k)
+class GradioInterface:
+    """Handles Gradio web interface setup and interactions."""
+    
+    def __init__(self):
+        """Initialize Gradio interface."""
+        self.chat_interface: Optional[ChatInterface] = None
+        self.demo = self._create_interface()
+
+    def _create_interface(self) -> gr.Blocks:
+        """Create and configure Gradio interface."""
+        with gr.Blocks(theme=gr.themes.Soft()) as demo:
+            gr.Markdown("""
+            # 🐕 LOSS DOG: Blockchain Wallet Analyzer
             
-            if openai_valid and etherscan_valid:
+            Welcome to LOSS DOG - Your friendly blockchain analysis companion!
+            - Enter your API keys below to get started
+            - Input an Ethereum wallet address to analyze
+            - Chat about your wallet contents with context!
+            """)
+
+            # API Keys Section
+            with gr.Row():
+                with gr.Column():
+                    openai_key = gr.Textbox(
+                        label="OpenAI API Key",
+                        type="password",
+                        placeholder="Enter your OpenAI API key..."
+                    )
+                with gr.Column():
+                    etherscan_key = gr.Textbox(
+                        label="Etherscan API Key",
+                        type="password",
+                        placeholder="Enter your Etherscan API key..."
+                    )
+
+            validation_status = gr.Textbox(
+                label="Validation Status",
+                interactive=False
+            )
+            validate_btn = gr.Button("Validate API Keys", variant="primary")
+
+            # Main Interface
+            with gr.Row():
+                # Chat Area (Left Side)
+                with gr.Column(scale=2):
+                    chatbot = gr.Chatbot(
+                        label="Chat History",
+                        height=500,
+                        value=[]
+                    )
+                    with gr.Row():
+                        msg_input = gr.Textbox(
+                            label="Message",
+                            placeholder="Enter wallet address or ask about holdings...",
+                            show_label=True
+                        )
+                        send_btn = gr.Button("Send", variant="primary")
+
+                # Context Sidebar (Right Side)
+                with gr.Column(scale=1):
+                    wallet_context = gr.JSON(
+                        label="Active Wallet Context",
+                        show_label=True,
+                        value={}
+                    )
+                    clear_btn = gr.Button("Clear Context", variant="secondary")
+
+            # Initial States
+            msg_input.interactive = False
+            send_btn.interactive = False
+
+            # Event Handlers
+            def validate_keys(openai_k: str, etherscan_k: str) -> Tuple[str, gr.update, gr.update]:
+                """Validate API keys and initialize chat interface."""
+                is_valid, message = ChatInterface._validate_api_keys(openai_k, etherscan_k)
+                
+                if is_valid:
+                    self.chat_interface = ChatInterface(openai_k, etherscan_k)
+                    return (
+                        "✅ API keys validated! You can start chatting now.",
+                        gr.update(interactive=True),
+                        gr.update(interactive=True)
+                    )
                 return (
-                    "✅ Both API keys are valid! You can start chatting now.",
-                    gr.update(interactive=True),
-                    gr.update(interactive=True)
+                    f"❌ Validation failed: {message}",
+                    gr.update(interactive=False),
+                    gr.update(interactive=False)
                 )
-            return (
-                f"❌ Validation failed:\n{openai_msg}\n{etherscan_msg}",
-                gr.update(interactive=False),
-                gr.update(interactive=False)
+
+            async def handle_message(
+                message: str,
+                chat_history: List[Tuple[str, str]],
+                context: Dict[str, Any]
+            ) -> Tuple[List[Tuple[str, str]], Dict[str, Any]]:
+                """Handle incoming messages."""
+                if not self.chat_interface:
+                    return [], {}
+                    
+                try:
+                    history, new_context, _ = await self.chat_interface.process_message(
+                        message,
+                        chat_history
+                    )
+                    return history, new_context
+                    
+                except Exception as e:
+                    logger.error(f"Error handling message: {e}")
+                    if chat_history is None:
+                        chat_history = []
+                    chat_history.append((message, f"Error: {str(e)}"))
+                    return chat_history, context
+
+            # Connect Event Handlers
+            validate_btn.click(
+                fn=validate_keys,
+                inputs=[openai_key, etherscan_key],
+                outputs=[validation_status, msg_input, send_btn]
             )
 
-        def clear_context() -> Tuple[Dict, List[Dict[str, str]]]:
-            """Clear the wallet context and chat history."""
-            empty_context = {}
-            empty_history = []  # Empty list for chat history
-            return empty_context, empty_history
-
-        async def handle_message(message: str, openai_k: str, etherscan_k: str, 
-                               chat_history: List[Dict[str, str]], context: Dict[str, Any]):
-            """Async wrapper for process_message."""
-            if message.strip() == "":
-                return chat_history, context
-            
-            try:
-                # Initialize empty history if None
-                if chat_history is None:
-                    chat_history = []
-                
-                # Initialize empty context if None
-                if context is None:
-                    context = {}
-                
-                # Process message
-                history, new_context, _ = await process_message(
-                    message, openai_k, etherscan_k, chat_history, context
+            if self.chat_interface:
+                clear_btn.click(
+                    fn=self.chat_interface.clear_context,
+                    inputs=[],
+                    outputs=[wallet_context, chatbot]
                 )
-                
-                return history, new_context
-            except Exception as e:
-                # Handle errors by adding them to chat history
-                if chat_history is None:
-                    chat_history = []
-                chat_history.append({"role": "user", "content": message})
-                chat_history.append({"role": "assistant", "content": f"Error: {str(e)}"})
-                return chat_history, context
-
-        # Connect Event Handlers
-        validate_btn.click(
-            fn=validate_keys,
-            inputs=[openai_key, etherscan_key],
-            outputs=[validation_status, msg_input, send_btn]
-        )
 
-        clear_btn.click(
-            fn=clear_context,
-            inputs=[],
-            outputs=[wallet_context, chatbot]
-        )
+            # Message Handling
+            msg_input.submit(
+                fn=handle_message,
+                inputs=[msg_input, chatbot, wallet_context],
+                outputs=[chatbot, wallet_context]
+            ).then(
+                lambda: gr.update(value=""),
+                None,
+                [msg_input]
+            )
 
-        # Message Handling
-        submit_event = msg_input.submit(
-            fn=handle_message,
-            inputs=[msg_input, openai_key, etherscan_key, chatbot, wallet_context],
-            outputs=[chatbot, wallet_context],
-            show_progress=True
-        ).then(
-            lambda: gr.update(value=""),
-            None,
-            [msg_input]
-        )
+            send_btn.click(
+                fn=handle_message,
+                inputs=[msg_input, chatbot, wallet_context],
+                outputs=[chatbot, wallet_context]
+            ).then(
+                lambda: gr.update(value=""),
+                None,
+                [msg_input]
+            )
 
-        send_event = send_btn.click(
-            fn=handle_message,
-            inputs=[msg_input, openai_key, etherscan_key, chatbot, wallet_context],
-            outputs=[chatbot, wallet_context],
-            show_progress=True
-        ).then(
-            lambda: gr.update(value=""),
-            None,
-            [msg_input]
-        )
+        return demo
 
-    return demo
+    def launch(self, **kwargs):
+        """Launch the Gradio interface."""
+        self.demo.queue()
+        self.demo.launch(**kwargs)
 
 
-###############################################################################
-#                              MAIN EXECUTION                                  #
-###############################################################################
+def main():
+    """Main entry point for the application."""
+    try:
+        # Load configuration
+        config = Config.load("config.json")
+        
+        # Initialize and launch interface
+        interface = GradioInterface()
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True
+        )
+        
+    except Exception as e:
+        logger.error(f"Application startup failed: {e}")
+        raise
+
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.queue()  # Enable queuing for async operations
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True
-    ) 
+    main()