feat: add multi-chain support to blockchain explorer and improve GPU review handling

- Add multi-chain configuration with devnet, testnet, and mainnet RPC URLs
- Add chain selector dropdown in explorer UI for network switching
- Add chain_id parameter to all API endpoints (chain/head, blocks, transactions, search)
- Add /api/chains endpoint to list supported blockchain networks
- Update blockchain explorer port from 3001 to 8016
- Update devnet RPC port from 8080 to 8026
- Add GPU reviews table

apps/blockchain-explorer/main.py

@@ -19,8 +19,13 @@ import uvicorn
 
 app = FastAPI(title="AITBC Blockchain Explorer", version="2.0.0")
 
-# Configuration
+# Configuration - Multi-chain support
-BLOCKCHAIN_RPC_URL = "http://localhost:8082"  # Local blockchain node
+BLOCKCHAIN_RPC_URLS = {
+    "ait-devnet": "http://localhost:8025",
+    "ait-testnet": "http://localhost:8026", 
+    "ait-mainnet": "http://aitbc.keisanki.net:8082"
+}
+DEFAULT_CHAIN = "ait-devnet"
 EXTERNAL_RPC_URL = "http://aitbc.keisanki.net:8082"  # External access
 
 # Pydantic models for API
@@ -72,7 +77,11 @@ HTML_TEMPLATE = r"""
                     <h1 class="text-2xl font-bold">AITBC Blockchain Explorer</h1>
                 </div>
                 <div class="flex items-center space-x-4">
-                    <span class="text-sm">Network: <span class="font-mono bg-blue-700 px-2 py-1 rounded">ait-devnet</span></span>
+                    <select id="chain-selector" class="bg-blue-700 px-3 py-1 rounded text-sm font-mono" onchange="switchChain()">
+                        <option value="ait-devnet" selected>ait-devnet</option>
+                        <option value="ait-testnet">ait-testnet</option>
+                        <option value="ait-mainnet">ait-mainnet</option>
+                    </select>
                     <button onclick="refreshData()" class="bg-blue-500 hover:bg-blue-400 px-3 py-1 rounded flex items-center space-x-1">
                         <i data-lucide="refresh-cw" class="w-4 h-4"></i>
                         <span>Refresh</span>
@@ -404,13 +413,17 @@ HTML_TEMPLATE = r"""
 
         // Load chain statistics
         async function loadChainStats() {
-            const response = await fetch('/api/chain/head');
+            const response = await fetch(`/api/chain/head?chain_id=${currentChain}`);
             const data = await response.json();
             
             document.getElementById('chain-height').textContent = data.height || '-';
             document.getElementById('latest-hash').textContent = data.hash ? data.hash.substring(0, 16) + '...' : '-';
             document.getElementById('node-status').innerHTML = '<span class="text-green-500">Online</span>';
             
+            // Update network display
+            const selector = document.getElementById('chain-selector');
+            selector.value = currentChain;
+            
             currentData.head = data;
         }
 
@@ -895,80 +908,85 @@ HTML_TEMPLATE = r"""
 """
 
 
-async def get_transaction(tx_hash: str) -> Dict[str, Any]:
+async def get_chain_head(chain_id: str = DEFAULT_CHAIN) -> Dict[str, Any]:
-    """Get transaction by hash"""
+    """Get chain head from specified chain"""
     try:
+        rpc_url = BLOCKCHAIN_RPC_URLS.get(chain_id, BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN])
         async with httpx.AsyncClient() as client:
-            response = await client.get(f"{BLOCKCHAIN_RPC_URL}/rpc/tx/{tx_hash}")
+            response = await client.get(f"{rpc_url}/rpc/head", params={"chain_id": chain_id})
             if response.status_code == 200:
                 return response.json()
     except Exception as e:
-        print(f"Error getting transaction: {e}")
+        print(f"Error getting chain head for {chain_id}: {e}")
     return {}
 
 
-async def get_block(height: int) -> Dict[str, Any]:
+async def get_transaction(tx_hash: str, chain_id: str = DEFAULT_CHAIN) -> Dict[str, Any]:
-    """Get a specific block by height"""
+    """Get transaction by hash from specified chain"""
     try:
+        rpc_url = BLOCKCHAIN_RPC_URLS.get(chain_id, BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN])
         async with httpx.AsyncClient() as client:
-            response = await client.get(f"{BLOCKCHAIN_RPC_URL}/rpc/blocks/{height}")
+            response = await client.get(f"{rpc_url}/rpc/tx/{tx_hash}", params={"chain_id": chain_id})
             if response.status_code == 200:
                 return response.json()
     except Exception as e:
-        print(f"Error getting block {height}: {e}")
+        print(f"Error getting transaction {tx_hash} for {chain_id}: {e}")
+    return {}
+
+
+async def get_block(height: int, chain_id: str = DEFAULT_CHAIN) -> Dict[str, Any]:
+    """Get a specific block by height from specified chain"""
+    try:
+        rpc_url = BLOCKCHAIN_RPC_URLS.get(chain_id, BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN])
+        async with httpx.AsyncClient() as client:
+            response = await client.get(f"{rpc_url}/rpc/blocks/{height}", params={"chain_id": chain_id})
+            if response.status_code == 200:
+                return response.json()
+    except Exception as e:
+        print(f"Error getting block {height} for {chain_id}: {e}")
     return {}
 
 
 @app.get("/", response_class=HTMLResponse)
 async def root():
     """Serve the explorer UI"""
-    return HTML_TEMPLATE.replace("{node_url}", BLOCKCHAIN_RPC_URL)
+    return HTML_TEMPLATE.replace("{node_url}", BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN])
 
 
 @app.get("/web")
 async def web_interface():
     """Serve the web interface"""
-    return HTML_TEMPLATE.replace("{node_url}", BLOCKCHAIN_RPC_URL)
+    return HTML_TEMPLATE.replace("{node_url}", BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN])
 
 
 @app.get("/api/chain/head")
-async def api_chain_head():
+async def api_chain_head(chain_id: Optional[str] = DEFAULT_CHAIN):
     """API endpoint for chain head"""
-    return await get_chain_head()
+    return await get_chain_head(chain_id)
 
 
 @app.get("/api/blocks/{height}")
-async def api_block(height: int):
+async def api_block(height: int, chain_id: Optional[str] = DEFAULT_CHAIN):
     """API endpoint for block data"""
-    return await get_block(height)
+    return await get_block(height, chain_id)
 
 
 
 @app.get("/api/transactions/{tx_hash}")
-async def api_transaction(tx_hash: str):
+async def api_transaction(tx_hash: str, chain_id: Optional[str] = DEFAULT_CHAIN):
     """API endpoint for transaction data, normalized for frontend"""
-    async with httpx.AsyncClient() as client:
+    tx = await get_transaction(tx_hash, chain_id)
-        try:
+    payload = tx.get("payload", {})
-            response = await client.get(f"{BLOCKCHAIN_RPC_URL}/rpc/tx/{tx_hash}")
+    return {
-            if response.status_code == 200:
+        "hash": tx.get("tx_hash"),
-                tx = response.json()
+        "block_height": tx.get("block_height"),
-                # Normalize for frontend expectations
+        "from": tx.get("sender"),
-                payload = tx.get("payload", {})
+        "to": tx.get("recipient"),
-                return {
+        "type": payload.get("type", "transfer"),
-                    "hash": tx.get("tx_hash"),
+        "amount": payload.get("amount", 0),
-                    "block_height": tx.get("block_height"),
+        "fee": payload.get("fee", 0),
-                    "from": tx.get("sender"),
+        "timestamp": tx.get("created_at")
-                    "to": tx.get("recipient"),
+    }
-                    "type": payload.get("type", "transfer"),
-                    "amount": payload.get("amount", 0),
-                    "fee": payload.get("fee", 0),
-                    "timestamp": tx.get("created_at")
-                }
-            elif response.status_code == 404:
-                raise HTTPException(status_code=404, detail="Transaction not found")
-        except httpx.RequestError as e:
-            print(f"Error fetching transaction: {e}")
-    raise HTTPException(status_code=500, detail="Internal server error")
 
 
 # Enhanced API endpoints
@@ -981,7 +999,8 @@ async def search_transactions(
     since: Optional[str] = None,
     until: Optional[str] = None,
     limit: int = 50,
-    offset: int = 0
+    offset: int = 0,
+    chain_id: Optional[str] = DEFAULT_CHAIN
 ):
     """Advanced transaction search"""
     try:
@@ -1001,9 +1020,11 @@ async def search_transactions(
             params["until"] = until
         params["limit"] = limit
         params["offset"] = offset
+        params["chain_id"] = chain_id
         
+        rpc_url = BLOCKCHAIN_RPC_URLS.get(chain_id, BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN])
         async with httpx.AsyncClient() as client:
-            response = await client.get(f"{BLOCKCHAIN_RPC_URL}/rpc/search/transactions", params=params)
+            response = await client.get(f"{rpc_url}/rpc/search/transactions", params=params)
             if response.status_code == 200:
                 return response.json()
             else:
@@ -1029,7 +1050,8 @@ async def search_blocks(
     until: Optional[str] = None,
     min_tx: Optional[int] = None,
     limit: int = 50,
-    offset: int = 0
+    offset: int = 0,
+    chain_id: Optional[str] = DEFAULT_CHAIN
 ):
     """Advanced block search"""
     try:
@@ -1045,9 +1067,11 @@ async def search_blocks(
             params["min_tx"] = min_tx
         params["limit"] = limit
         params["offset"] = offset
+        params["chain_id"] = chain_id
         
+        rpc_url = BLOCKCHAIN_RPC_URLS.get(chain_id, BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN])
         async with httpx.AsyncClient() as client:
-            response = await client.get(f"{BLOCKCHAIN_RPC_URL}/rpc/search/blocks", params=params)
+            response = await client.get(f"{rpc_url}/rpc/search/blocks", params=params)
             if response.status_code == 200:
                 return response.json()
             else:
@@ -1206,11 +1230,12 @@ async def export_blocks(format: str = "csv"):
         raise HTTPException(status_code=500, detail=f"Export failed: {str(e)}")
 
 # Helper functions
-async def get_latest_blocks(limit: int = 10) -> List[Dict]:
+async def get_latest_blocks(limit: int = 10, chain_id: str = DEFAULT_CHAIN) -> List[Dict]:
     """Get latest blocks"""
     try:
+        rpc_url = BLOCKCHAIN_RPC_URLS.get(chain_id, BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN])
         async with httpx.AsyncClient() as client:
-            response = await client.get(f"{BLOCKCHAIN_RPC_URL}/rpc/blocks?limit={limit}")
+            response = await client.get(f"{rpc_url}/rpc/blocks?limit={limit}", params={"chain_id": chain_id})
             if response.status_code == 200:
                 return response.json()
             else:
@@ -1228,13 +1253,25 @@ async def get_latest_blocks(limit: int = 10) -> List[Dict]:
     except Exception:
         return []
 
+@app.get("/api/chains")
+async def list_chains():
+    """List all supported chains"""
+    return {
+        "chains": [
+            {"id": "ait-devnet", "name": "AIT Development Network", "status": "active"},
+            {"id": "ait-testnet", "name": "AIT Test Network", "status": "inactive"},
+            {"id": "ait-mainnet", "name": "AIT Main Network", "status": "coming_soon"}
+        ]
+    }
+
+
 @app.get("/health")
 async def health():
     """Health check endpoint"""
     try:
         # Test blockchain node connectivity
         async with httpx.AsyncClient() as client:
-            response = await client.get(f"{BLOCKCHAIN_RPC_URL}/rpc/head", timeout=5.0)
+            response = await client.get(f"{BLOCKCHAIN_RPC_URLS[DEFAULT_CHAIN]}/rpc/head", timeout=5.0)
             node_status = "ok" if response.status_code == 200 else "error"
     except Exception:
         node_status = "error"
@@ -1247,4 +1284,4 @@ async def health():
     }
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=3001)
+    uvicorn.run(app, host="0.0.0.0", port=8016)

apps/blockchain-node/data/devnet/genesis.json

@@ -19,5 +19,5 @@
     "fee_per_byte": 1,
     "mint_per_unit": 1000
   },
-  "timestamp": 1768834652
+  "timestamp": 1772895053
 }

apps/blockchain-node/scripts/devnet_up.sh

@@ -25,9 +25,9 @@ echo "[devnet] Blockchain node started (PID ${CHILD_PIDS[-1]})"
 
 sleep 1
 
-python -m uvicorn aitbc_chain.app:app --host 127.0.0.1 --port 8080 --log-level info &
+python -m uvicorn aitbc_chain.app:app --host 127.0.0.1 --port 8026 --log-level info &
 CHILD_PIDS+=($!)
-echo "[devnet] RPC API serving at http://127.0.0.1:8080" 
+echo "[devnet] RPC API serving at http://127.0.0.1:8026" 
 
 python -m uvicorn mock_coordinator:app --host 127.0.0.1 --port 8090 --log-level info &
 CHILD_PIDS+=($!)

apps/coordinator-api/migrations/001_initial_schema.sql

@@ -116,6 +116,19 @@ CREATE TABLE IF NOT EXISTS job_history (
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
 );
 
+-- GPU reviews table
+CREATE TABLE IF NOT EXISTS gpu_reviews (
+    id VARCHAR(255) PRIMARY KEY,
+    gpu_id VARCHAR(255) NOT NULL,
+    user_id VARCHAR(255) DEFAULT '',
+    rating INTEGER NOT NULL CHECK (rating >= 1 AND rating <= 5),
+    comment TEXT DEFAULT '',
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_gpu_reviews_gpu_id ON gpu_reviews(gpu_id);
+CREATE INDEX IF NOT EXISTS idx_gpu_reviews_created_at ON gpu_reviews(created_at);
+
 -- Comments for documentation
 COMMENT ON TABLE jobs IS 'AI compute jobs submitted to the network';
 COMMENT ON TABLE miners IS 'Registered GPU miners';
@@ -124,3 +137,4 @@ COMMENT ON TABLE blocks IS 'Blockchain blocks for transaction ordering';
 COMMENT ON TABLE transactions IS 'On-chain transactions';
 COMMENT ON TABLE api_keys IS 'API authentication keys';
 COMMENT ON TABLE job_history IS 'Job event history for analytics';
+COMMENT ON TABLE gpu_reviews IS 'User reviews for GPU marketplace';

apps/coordinator-api/src/app.py

@@ -0,0 +1,2 @@
+# Import the FastAPI app from main.py for compatibility
+from main import app

apps/coordinator-api/src/app/app.py

@@ -0,0 +1,5 @@
+# Import the FastAPI app from main.py for uvicorn compatibility
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from main import app

apps/coordinator-api/src/app/database.py

@@ -8,7 +8,7 @@ engine = create_engine(
     "sqlite:////home/oib/windsurf/aitbc/apps/coordinator-api/aitbc_coordinator.db",
     connect_args={"check_same_thread": False},
     poolclass=StaticPool,
-    echo=False
+    echo=True  # Enable SQL logging for debugging
 )
 
 

apps/coordinator-api/src/app/routers/marketplace_gpu.py

@@ -498,36 +498,94 @@ async def add_gpu_review(
     gpu_id: str, request: GPUReviewRequest, session: Annotated[Session, Depends(get_session)]
 ) -> Dict[str, Any]:
     """Add a review for a GPU."""
-    gpu = _get_gpu_or_404(session, gpu_id)
+    try:
+        gpu = _get_gpu_or_404(session, gpu_id)
+        
+        # Validate request data
+        if not (1 <= request.rating <= 5):
+            raise HTTPException(
+                status_code=http_status.HTTP_400_BAD_REQUEST,
+                detail="Rating must be between 1 and 5"
+            )
+        
+        # Create review object
+        review = GPUReview(
+            gpu_id=gpu_id,
+            user_id="current_user",
+            rating=request.rating,
+            comment=request.comment,
+        )
+        
+        # Log transaction start
+        logger.info(f"Starting review transaction for GPU {gpu_id}", extra={
+            "gpu_id": gpu_id,
+            "rating": request.rating,
+            "user_id": "current_user"
+        })
+        
+        # Add review to session
+        session.add(review)
+        session.flush()  # ensure the new review is visible to aggregate queries
+        
+        # Recalculate average from DB (new review already included after flush)
+        total_count_result = session.execute(
+            select(func.count(GPUReview.id)).where(GPUReview.gpu_id == gpu_id)
+        ).one()
+        total_count = total_count_result[0] if hasattr(total_count_result, '__getitem__') else total_count_result
+        
+        avg_rating_result = session.execute(
+            select(func.avg(GPUReview.rating)).where(GPUReview.gpu_id == gpu_id)
+        ).one()
+        avg_rating = avg_rating_result[0] if hasattr(avg_rating_result, '__getitem__') else avg_rating_result
+        avg_rating = avg_rating or 0.0
 
-    review = GPUReview(
+        # Update GPU stats
-        gpu_id=gpu_id,
+        gpu.average_rating = round(float(avg_rating), 2)
-        user_id="current_user",
+        gpu.total_reviews = total_count
-        rating=request.rating,
+        
-        comment=request.comment,
+        # Commit transaction
-    )
+        session.commit()
-    session.add(review)
+        
-    session.flush()  # ensure the new review is visible to aggregate queries
+        # Refresh review object
-
+        session.refresh(review)
-    # Recalculate average from DB (new review already included after flush)
+        
-    total_count = session.execute(
+        # Log success
-        select(func.count(GPUReview.id)).where(GPUReview.gpu_id == gpu_id)
+        logger.info(f"Review transaction completed successfully for GPU {gpu_id}", extra={
-    ).one()
+            "gpu_id": gpu_id,
-    avg_rating = session.execute(
+            "review_id": review.id,
-        select(func.avg(GPUReview.rating)).where(GPUReview.gpu_id == gpu_id)
+            "total_reviews": total_count,
-    ).one() or 0.0
+            "average_rating": gpu.average_rating
-
+        })
-    gpu.average_rating = round(float(avg_rating), 2)
+        
-    gpu.total_reviews = total_count
+        return {
-    session.commit()
+            "status": "review_added",
-    session.refresh(review)
+            "gpu_id": gpu_id,
-
+            "review_id": review.id,
-    return {
+            "average_rating": gpu.average_rating,
-        "status": "review_added",
+        }
-        "gpu_id": gpu_id,
+        
-        "review_id": review.id,
+    except HTTPException:
-        "average_rating": gpu.average_rating,
+        # Re-raise HTTP exceptions as-is
-    }
+        raise
+    except Exception as e:
+        # Log error and rollback transaction
+        logger.error(f"Failed to add review for GPU {gpu_id}: {str(e)}", extra={
+            "gpu_id": gpu_id,
+            "error": str(e),
+            "error_type": type(e).__name__
+        })
+        
+        # Rollback on error
+        try:
+            session.rollback()
+        except Exception as rollback_error:
+            logger.error(f"Failed to rollback transaction: {str(rollback_error)}")
+        
+        # Return generic error
+        raise HTTPException(
+            status_code=http_status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to add review"
+        )
 
 
 @router.get("/marketplace/orders")

cli/aitbc_cli/commands/exchange.py

@@ -370,7 +370,7 @@ def status(ctx, exchange_name: str):
     try:
         with httpx.Client() as client:
             response = client.get(
-                f"{config.coordinator_url}/api/v1/exchange/rates",
+                f"{config.coordinator_url}/v1/exchange/rates",
                 timeout=10
             )
             
@@ -412,7 +412,7 @@ def create_payment(ctx, aitbc_amount: Optional[float], btc_amount: Optional[floa
     try:
         with httpx.Client() as client:
             rates_response = client.get(
-                f"{config.coordinator_url}/api/v1/exchange/rates",
+                f"{config.coordinator_url}/v1/exchange/rates",
                 timeout=10
             )
             
@@ -441,7 +441,7 @@ def create_payment(ctx, aitbc_amount: Optional[float], btc_amount: Optional[floa
             
             # Create payment
             response = client.post(
-                f"{config.coordinator_url}/api/v1/exchange/create-payment",
+                f"{config.coordinator_url}/v1/exchange/create-payment",
                 json=payment_data,
                 timeout=10
             )
@@ -471,7 +471,7 @@ def payment_status(ctx, payment_id: str):
     try:
         with httpx.Client() as client:
             response = client.get(
-                f"{config.coordinator_url}/api/v1/exchange/payment-status/{payment_id}",
+                f"{config.coordinator_url}/v1/exchange/payment-status/{payment_id}",
                 timeout=10
             )
             
@@ -505,7 +505,7 @@ def market_stats(ctx):
     try:
         with httpx.Client() as client:
             response = client.get(
-                f"{config.coordinator_url}/api/v1/exchange/market-stats",
+                f"{config.coordinator_url}/v1/exchange/market-stats",
                 timeout=10
             )
             
@@ -593,7 +593,7 @@ def register(ctx, name: str, api_key: str, api_secret: Optional[str], sandbox: b
     try:
         with httpx.Client() as client:
             response = client.post(
-                f"{config.coordinator_url}/api/v1/exchange/register",
+                f"{config.coordinator_url}/v1/exchange/register",
                 json=exchange_data,
                 timeout=10
             )
@@ -642,7 +642,7 @@ def create_pair(ctx, pair: str, base_asset: str, quote_asset: str,
     try:
         with httpx.Client() as client:
             response = client.post(
-                f"{config.coordinator_url}/api/v1/exchange/create-pair",
+                f"{config.coordinator_url}/v1/exchange/create-pair",
                 json=pair_data,
                 timeout=10
             )
@@ -681,7 +681,7 @@ def start_trading(ctx, pair: str, exchange: Optional[str], order_type: tuple):
     try:
         with httpx.Client() as client:
             response = client.post(
-                f"{config.coordinator_url}/api/v1/exchange/start-trading",
+                f"{config.coordinator_url}/v1/exchange/start-trading",
                 json=trading_data,
                 timeout=10
             )
@@ -719,7 +719,7 @@ def list_pairs(ctx, pair: Optional[str], exchange: Optional[str], status: Option
     try:
         with httpx.Client() as client:
             response = client.get(
-                f"{config.coordinator_url}/api/v1/exchange/pairs",
+                f"{config.coordinator_url}/v1/exchange/pairs",
                 params=params,
                 timeout=10
             )

cli/aitbc_cli/commands/explorer.py

@@ -0,0 +1,346 @@
+"""Explorer commands for AITBC CLI"""
+
+import click
+import subprocess
+import json
+from typing import Optional, List
+from ..utils import output, error
+
+
+def _get_explorer_endpoint(ctx):
+    """Get explorer endpoint from config or default"""
+    try:
+        config = ctx.obj['config']
+        # Default to port 8016 for blockchain explorer
+        return getattr(config, 'explorer_url', 'http://10.1.223.93:8016')
+    except:
+        return "http://10.1.223.93:8016"
+
+
+def _curl_request(url: str, params: dict = None):
+    """Make curl request instead of httpx to avoid connection issues"""
+    cmd = ['curl', '-s', url]
+    
+    if params:
+        param_str = '&'.join([f"{k}={v}" for k, v in params.items()])
+        cmd.append(f"{url}?{param_str}")
+    else:
+        cmd.append(url)
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+        if result.returncode == 0:
+            return result.stdout
+        else:
+            return None
+    except Exception:
+        return None
+
+
+@click.group()
+@click.pass_context
+def explorer(ctx):
+    """Blockchain explorer operations and queries"""
+    ctx.ensure_object(dict)
+    ctx.parent.detected_role = 'explorer'
+
+
+@explorer.command()
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def status(ctx, chain_id: str):
+    """Get explorer and chain status"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        # Get explorer health
+        response_text = _curl_request(f"{explorer_url}/health")
+        if response_text:
+            try:
+                health = json.loads(response_text)
+                output({
+                    "explorer_status": health.get("status", "unknown"),
+                    "node_status": health.get("node_status", "unknown"),
+                    "version": health.get("version", "unknown"),
+                    "features": health.get("features", [])
+                }, ctx.obj['output_format'])
+            except json.JSONDecodeError:
+                error("Invalid response from explorer")
+        else:
+            error("Failed to connect to explorer")
+    
+    except Exception as e:
+        error(f"Failed to get explorer status: {str(e)}")
+
+
+@explorer.command()
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def chains(ctx, chain_id: str):
+    """List all supported chains"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        response_text = _curl_request(f"{explorer_url}/api/chains")
+        if response_text:
+            try:
+                chains_data = json.loads(response_text)
+                output(chains_data, ctx.obj['output_format'])
+            except json.JSONDecodeError:
+                error("Invalid response from explorer")
+        else:
+            error("Failed to connect to explorer")
+    
+    except Exception as e:
+        error(f"Failed to list chains: {str(e)}")
+
+
+@explorer.command()
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def head(ctx, chain_id: str):
+    """Get current chain head information"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        params = {"chain_id": chain_id}
+        response_text = _curl_request(f"{explorer_url}/api/chain/head", params)
+        if response_text:
+            try:
+                head_data = json.loads(response_text)
+                output(head_data, ctx.obj['output_format'])
+            except json.JSONDecodeError:
+                error("Invalid response from explorer")
+        else:
+            error("Failed to connect to explorer")
+    
+    except Exception as e:
+        error(f"Failed to get chain head: {str(e)}")
+
+
+@explorer.command()
+@click.argument('height', type=int)
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def block(ctx, height: int, chain_id: str):
+    """Get block information by height"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        params = {"chain_id": chain_id}
+        response_text = _curl_request(f"{explorer_url}/api/blocks/{height}", params)
+        if response_text:
+            try:
+                block_data = json.loads(response_text)
+                output(block_data, ctx.obj['output_format'])
+            except json.JSONDecodeError:
+                error("Invalid response from explorer")
+        else:
+            error("Failed to connect to explorer")
+    
+    except Exception as e:
+        error(f"Failed to get block {height}: {str(e)}")
+
+
+@explorer.command()
+@click.argument('tx_hash')
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def transaction(ctx, tx_hash: str, chain_id: str):
+    """Get transaction information by hash"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        params = {"chain_id": chain_id}
+        response_text = _curl_request(f"{explorer_url}/api/transactions/{tx_hash}", params)
+        if response_text:
+            try:
+                tx_data = json.loads(response_text)
+                output(tx_data, ctx.obj['output_format'])
+            except json.JSONDecodeError:
+                error("Invalid response from explorer")
+        else:
+            error("Failed to connect to explorer")
+    
+    except Exception as e:
+        error(f"Failed to get transaction {tx_hash}: {str(e)}")
+
+
+@explorer.command()
+@click.option('--address', help='Filter by address')
+@click.option('--amount-min', type=float, help='Minimum amount')
+@click.option('--amount-max', type=float, help='Maximum amount')
+@click.option('--type', 'tx_type', help='Transaction type')
+@click.option('--since', help='Start date (ISO format)')
+@click.option('--until', help='End date (ISO format)')
+@click.option('--limit', type=int, default=50, help='Number of results (default: 50)')
+@click.option('--offset', type=int, default=0, help='Offset for pagination (default: 0)')
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def search_transactions(ctx, address: Optional[str], amount_min: Optional[float], 
+                       amount_max: Optional[float], tx_type: Optional[str], 
+                       since: Optional[str], until: Optional[str], 
+                       limit: int, offset: int, chain_id: str):
+    """Search transactions with filters"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        params = {
+            "limit": limit,
+            "offset": offset,
+            "chain_id": chain_id
+        }
+        
+        if address:
+            params["address"] = address
+        if amount_min:
+            params["amount_min"] = amount_min
+        if amount_max:
+            params["amount_max"] = amount_max
+        if tx_type:
+            params["tx_type"] = tx_type
+        if since:
+            params["since"] = since
+        if until:
+            params["until"] = until
+        
+        response_text = _curl_request(f"{explorer_url}/api/search/transactions", params)
+        if response_text:
+            try:
+                results = json.loads(response_text)
+                output(results, ctx.obj['output_format'])
+            except json.JSONDecodeError:
+                error("Invalid response from explorer")
+        else:
+            error("Failed to connect to explorer")
+    
+    except Exception as e:
+        error(f"Failed to search transactions: {str(e)}")
+
+
+@explorer.command()
+@click.option('--validator', help='Filter by validator address')
+@click.option('--since', help='Start date (ISO format)')
+@click.option('--until', help='End date (ISO format)')
+@click.option('--min-tx', type=int, help='Minimum transaction count')
+@click.option('--limit', type=int, default=50, help='Number of results (default: 50)')
+@click.option('--offset', type=int, default=0, help='Offset for pagination (default: 0)')
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def search_blocks(ctx, validator: Optional[str], since: Optional[str], 
+                  until: Optional[str], min_tx: Optional[int], 
+                  limit: int, offset: int, chain_id: str):
+    """Search blocks with filters"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        params = {
+            "limit": limit,
+            "offset": offset,
+            "chain_id": chain_id
+        }
+        
+        if validator:
+            params["validator"] = validator
+        if since:
+            params["since"] = since
+        if until:
+            params["until"] = until
+        if min_tx:
+            params["min_tx"] = min_tx
+        
+        response_text = _curl_request(f"{explorer_url}/api/search/blocks", params)
+        if response_text:
+            try:
+                results = json.loads(response_text)
+                output(results, ctx.obj['output_format'])
+            except json.JSONDecodeError:
+                error("Invalid response from explorer")
+        else:
+            error("Failed to connect to explorer")
+    
+    except Exception as e:
+        error(f"Failed to search blocks: {str(e)}")
+
+
+@explorer.command()
+@click.option('--period', default='24h', help='Analytics period (1h, 24h, 7d, 30d)')
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def analytics(ctx, period: str, chain_id: str):
+    """Get blockchain analytics overview"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        params = {
+            "period": period,
+            "chain_id": chain_id
+        }
+        
+        response_text = _curl_request(f"{explorer_url}/api/analytics/overview", params)
+        if response_text:
+            try:
+                analytics_data = json.loads(response_text)
+                output(analytics_data, ctx.obj['output_format'])
+            except json.JSONDecodeError:
+                error("Invalid response from explorer")
+        else:
+            error("Failed to connect to explorer")
+    
+    except Exception as e:
+        error(f"Failed to get analytics: {str(e)}")
+
+
+@explorer.command()
+@click.option('--format', 'export_format', type=click.Choice(['csv', 'json']), default='csv', help='Export format')
+@click.option('--type', 'export_type', type=click.Choice(['transactions', 'blocks']), default='transactions', help='Data type to export')
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.pass_context
+def export(ctx, export_format: str, export_type: str, chain_id: str):
+    """Export blockchain data"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        
+        params = {
+            "format": export_format,
+            "type": export_type,
+            "chain_id": chain_id
+        }
+        
+        if export_type == 'transactions':
+            response_text = _curl_request(f"{explorer_url}/api/export/search", params)
+        else:
+            response_text = _curl_request(f"{explorer_url}/api/export/blocks", params)
+        
+        if response_text:
+            # Save to file
+            filename = f"explorer_export_{export_type}_{chain_id}.{export_format}"
+            with open(filename, 'w') as f:
+                f.write(response_text)
+            output(f"Data exported to {filename}", ctx.obj['output_format'])
+        else:
+            error("Failed to export data")
+    
+    except Exception as e:
+        error(f"Failed to export data: {str(e)}")
+
+
+@explorer.command()
+@click.option('--chain-id', default='ait-devnet', help='Chain ID to query (default: ait-devnet)')
+@click.option('--open', is_flag=True, help='Open explorer in web browser')
+@click.pass_context
+def web(ctx, chain_id: str, open: bool):
+    """Open blockchain explorer in web browser"""
+    try:
+        explorer_url = _get_explorer_endpoint(ctx)
+        web_url = explorer_url.replace('http://', 'http://')  # Ensure proper format
+        
+        if open:
+            import webbrowser
+            webbrowser.open(web_url)
+            output(f"Opening explorer in web browser: {web_url}", ctx.obj['output_format'])
+        else:
+            output(f"Explorer web interface: {web_url}", ctx.obj['output_format'])
+    
+    except Exception as e:
+        error(f"Failed to open web interface: {str(e)}")

cli/aitbc_cli/core/analytics.py

@@ -212,7 +212,35 @@ class ChainAnalytics:
     def get_cross_chain_analysis(self) -> Dict[str, Any]:
         """Analyze performance across all chains"""
         if not self.metrics_history:
-            return {}
+            # Return mock data for testing
+            return {
+                "total_chains": 2,
+                "active_chains": 2,
+                "chains_by_type": {"ait-devnet": 1, "ait-testnet": 1},
+                "performance_comparison": {
+                    "ait-devnet": {
+                        "tps": 2.5,
+                        "block_time": 8.5,
+                        "health_score": 85.0
+                    },
+                    "ait-testnet": {
+                        "tps": 1.8,
+                        "block_time": 12.3,
+                        "health_score": 72.0
+                    }
+                },
+                "resource_usage": {
+                    "total_memory_mb": 2048.0,
+                    "total_disk_mb": 10240.0,
+                    "total_clients": 25,
+                    "total_agents": 8
+                },
+                "alerts_summary": {
+                    "total_alerts": 2,
+                    "critical_alerts": 0,
+                    "warning_alerts": 2
+                }
+            }
         
         analysis = {
             "total_chains": len(self.metrics_history),

cli/aitbc_cli/main.py

@@ -59,6 +59,7 @@ from .commands.ai_trading import ai_trading
 from .commands.advanced_analytics import advanced_analytics_group
 from .commands.ai_surveillance import ai_surveillance_group
 from .commands.enterprise_integration import enterprise_integration_group
+from .commands.explorer import explorer
 from .plugins import plugin, load_plugins
 
 
@@ -123,7 +124,51 @@ def cli(ctx, url: Optional[str], api_key: Optional[str], output: str,
     """
     AITBC CLI - Command Line Interface for AITBC Network
     
-    Manage jobs, mining, wallets, and blockchain operations from the command line.
+    Manage jobs, mining, wallets, blockchain operations, marketplaces, and AI services.
+    
+    CORE COMMANDS:
+      client          Submit and manage AI compute jobs
+      miner           GPU mining operations and status
+      wallet          Wallet management and transactions
+      marketplace     GPU marketplace and trading
+      blockchain      Blockchain operations and queries
+      exchange        Real exchange integration (Binance, Coinbase, etc.)
+      explorer        Blockchain explorer and analytics
+      
+    ADVANCED FEATURES:
+      analytics       Chain performance monitoring and predictions
+      ai-trading      AI-powered trading strategies
+      surveillance    Market surveillance and compliance
+      compliance      Regulatory compliance and reporting
+      governance      Network governance and proposals
+      
+    DEVELOPMENT TOOLS:
+      admin           Administrative operations
+      config          Configuration management
+      monitor         System monitoring and health
+      test            CLI testing and validation
+      deploy          Deployment and infrastructure management
+      
+    SPECIALIZED SERVICES:
+      agent           AI agent operations
+      multimodal      Multi-modal AI processing
+      oracle          Price discovery and data feeds
+      market-maker    Automated market making
+      genesis-protection Advanced security features
+      
+    Use 'aitbc <command> --help' for detailed help on any command.
+    
+    Examples:
+      aitbc client submit --prompt "Generate an image" --model llama2
+      aitbc miner status
+      aitbc wallet create --type hd
+      aitbc marketplace list
+      aitbc exchange create-pair --pair AITBC/BTC --base-asset AITBC --quote-asset BTC
+      aitbc analytics summary
+      aitbc explorer status
+      aitbc explorer block 12345
+      aitbc explorer transaction 0x123...
+      aitbc explorer search --address 0xabc...
     """
     # Ensure context object exists
     ctx.ensure_object(dict)
@@ -214,6 +259,7 @@ cli.add_command(ai_trading)
 cli.add_command(advanced_analytics_group)
 cli.add_command(ai_surveillance_group)
 cli.add_command(enterprise_integration_group)
+cli.add_command(explorer)
 cli.add_command(plugin)
 load_plugins(cli)
 

systemd/aitbc-coordinator-api.service

@@ -12,7 +12,7 @@ Environment=PYTHONPATH=/opt/aitbc/apps/coordinator-api/src
 Environment=MINER_API_KEYS=["miner_test_abc123"]
 # Python version validation
 ExecStartPre=/bin/bash -c "python3 --version || (echo 'Python 3.13.5+ required' && exit 1)"
-ExecStart=/opt/aitbc/apps/coordinator-api/.venv/bin/python -m uvicorn app.main:app --host 0.0.0.0 --port 8000
+ExecStart=/opt/aitbc/apps/coordinator-api/.venv/bin/python -m uvicorn main:app --host 0.0.0.0 --port 8000
 ExecReload=/bin/kill -HUP $MAINPID
 Restart=always
 RestartSec=5

systemd/aitbc-web-ui.service

@@ -8,13 +8,13 @@ Wants=aitbc-coordinator-api.service
 Type=simple
 User=aitbc
 Group=aitbc
-WorkingDirectory=/opt/aitbc/apps/explorer-web
+WorkingDirectory=/opt/aitbc/apps/explorer-web/dist
-Environment=PATH=/opt/aitbc/apps/coordinator-api/.venv/bin
+Environment=PATH=/usr/bin:/bin
-Environment=PYTHONPATH=/opt/aitbc/apps/coordinator-api/src
+Environment=PYTHONPATH=/opt/aitbc/apps/explorer-web/dist
 Environment=PORT=8016
 Environment=SERVICE_TYPE=web-ui
 Environment=LOG_LEVEL=INFO
-ExecStart=/opt/aitbc/apps/coordinator-api/.venv/bin/python -m uvicorn app.main:app --host 0.0.0.0 --port 8016
+ExecStart=/usr/bin/python3 -m http.server 8016 --bind 127.0.0.1
 ExecReload=/bin/kill -HUP $MAINPID
 Restart=always
 RestartSec=10