diff --git a/RELAY_HUB_ARCHITECTURE.md b/RELAY_HUB_ARCHITECTURE.md
new file mode 100644
index 0000000..b7c6922
--- /dev/null
+++ b/RELAY_HUB_ARCHITECTURE.md
@@ -0,0 +1,356 @@
+# Central Relay Hub Architecture
+
+## Overview
+
+The Ario application uses a centralized relay hub architecture to manage all Nostr relay connections. This design provides a single point of connection management, efficient resource sharing, and consistent relay behavior across all components.
+
+## Architecture Components
+
+### 1. Core Relay Hub (`relayHub.ts`)
+
+The `RelayHub` class is the foundation of the relay management system, built on top of `nostr-tools` SimplePool.
+
+**Key Features:**
+- **Singleton Pattern**: Single instance manages all relay connections
+- **Connection Pooling**: Efficiently manages multiple relay connections
+- **Automatic Reconnection**: Handles connection failures and reconnection logic
+- **Health Monitoring**: Regular health checks and status reporting
+- **Mobile Optimization**: Handles mobile app visibility changes
+- **Event Emission**: Provides event-driven architecture for status updates
+
+**Location:** `src/lib/nostr/relayHub.ts`
+
+### 2. Relay Hub Composable (`useRelayHub.ts`)
+
+A Vue 3 composable that provides a reactive interface to the relay hub.
+
+**Key Features:**
+- **Reactive State**: `isConnected`, `connectionStatus`, `relayStatuses`
+- **Connection Management**: `initialize()`, `connect()`, `disconnect()`
+- **Subscription Management**: `subscribe()`, `unsubscribe()`
+- **Event Publishing**: `publishEvent()`, `queryEvents()`
+- **Health Monitoring**: Connection health percentages and status
+
+**Location:** `src/composables/useRelayHub.ts`
+
+### 3. Application Integration (`App.vue`)
+
+The main application component initializes the relay hub at startup.
+
+**Key Integration Points:**
+```typescript
+// Initialize relay hub
+const relayHub = useRelayHub()
+
+onMounted(async () => {
+  // Initialize relay hub
+  try {
+    await relayHub.initialize()
+    console.log('Relay hub initialized successfully')
+  } catch (error) {
+    console.error('Failed to initialize relay hub:', error)
+  }
+})
+```
+
+## How Components Plug Into the Relay Hub
+
+### 1. Direct Integration via `useRelayHub()`
+
+Components can directly use the relay hub composable:
+
+```typescript
+import { useRelayHub } from '@/composables/useRelayHub'
+
+export default {
+  setup() {
+    const relayHub = useRelayHub()
+    
+    // Access reactive state
+    const isConnected = relayHub.isConnected
+    const connectionStatus = relayHub.connectionStatus
+    
+    // Use connection methods
+    const connect = async () => {
+      await relayHub.connect()
+    }
+    
+    // Subscribe to events
+    const unsubscribe = relayHub.subscribe({
+      id: 'my-subscription',
+      filters: [{ kinds: [1] }], // Text notes
+      onEvent: (event) => {
+        console.log('Received event:', event)
+      }
+    })
+    
+    // Clean up on unmount
+    onUnmounted(() => {
+      unsubscribe()
+    })
+    
+    return {
+      isConnected,
+      connectionStatus,
+      connect
+    }
+  }
+}
+```
+
+### 2. Indirect Integration via Specialized Composables
+
+Components can use specialized composables that internally use the relay hub:
+
+#### Chat Integration (`useNostrChat.ts`)
+
+The chat system integrates with the relay hub for message handling:
+
+```typescript
+// Inside useNostrChat.ts
+const subscribeToPeer = async (peerPubkey: string) => {
+  // Check connection status
+  if (!relayHub.isConnected.value) {
+    await relayHub.connect()
+  }
+  
+  // Subscribe to peer messages
+  const unsubscribe = relayHub.subscribe({
+    id: `peer-${peerPubkey}`,
+    filters: [
+      {
+        kinds: [4], // Direct messages
+        '#p': [currentUser.value.pubkey],
+        authors: [peerPubkey]
+      }
+    ],
+    onEvent: (event) => handleIncomingMessage(event, peerPubkey)
+  })
+  
+  return unsubscribe
+}
+```
+
+#### Market Integration (`useMarket.ts`)
+
+The market system can integrate similarly:
+
+```typescript
+// Example market integration
+const subscribeToMarketEvents = async () => {
+  if (!relayHub.isConnected.value) {
+    await relayHub.connect()
+  }
+  
+  return relayHub.subscribe({
+    id: 'market-events',
+    filters: [
+      {
+        kinds: [30000], // Custom market events
+        '#t': ['market']
+      }
+    ],
+    onEvent: (event) => handleMarketEvent(event)
+  })
+}
+```
+
+### 3. Configuration and Setup
+
+#### Relay Configuration
+
+Relays are configured in the application config:
+
+```typescript
+// src/lib/config.ts
+export const config = {
+  nostr: {
+    relays: [
+      'wss://relay.ariege.io',
+      'wss://lnbits.ariege.io/nostrrelay/benac'
+    ]
+  }
+}
+```
+
+#### Initialization Order
+
+1. **App.vue** initializes the relay hub
+2. **Components** can use the relay hub immediately after initialization
+3. **Specialized composables** handle their own relay hub integration
+
+## Benefits of the Central Relay Hub Architecture
+
+### 1. **Resource Efficiency**
+- Single connection pool for all relay connections
+- Shared connection management across components
+- Reduced memory usage and connection overhead
+
+### 2. **Consistent Behavior**
+- Unified connection status across the application
+- Consistent error handling and reconnection logic
+- Standardized relay health monitoring
+
+### 3. **Scalability**
+- Easy to add new relay endpoints
+- Centralized configuration management
+- Simple to extend with new relay features
+
+### 4. **Maintainability**
+- Single point of truth for relay logic
+- Easier debugging and monitoring
+- Centralized relay-related bug fixes
+
+## Best Practices for Component Integration
+
+### 1. **Always Check Connection Status**
+
+```typescript
+const myFunction = async () => {
+  if (!relayHub.isConnected.value) {
+    await relayHub.connect()
+  }
+  // Proceed with relay operations
+}
+```
+
+### 2. **Use Subscription IDs**
+
+```typescript
+const subscriptionId = `my-component-${Date.now()}`
+const unsubscribe = relayHub.subscribe({
+  id: subscriptionId,
+  filters: [...],
+  onEvent: handleEvent
+})
+```
+
+### 3. **Clean Up Subscriptions**
+
+```typescript
+onUnmounted(() => {
+  if (unsubscribe) {
+    unsubscribe()
+  }
+})
+```
+
+### 4. **Handle Connection Errors**
+
+```typescript
+const connect = async () => {
+  try {
+    await relayHub.connect()
+  } catch (error) {
+    console.error('Failed to connect:', error)
+    // Handle error appropriately
+  }
+}
+```
+
+### 5. **Monitor Connection Health**
+
+```typescript
+const connectionHealth = computed(() => relayHub.connectionHealth)
+const isHealthy = computed(() => connectionHealth.value > 50)
+```
+
+## Example: Creating a New Relay-Enabled Component
+
+Here's a complete example of a new component that uses the relay hub:
+
+```vue
+<template>
+  <div>
+    <div>Connection Status: {{ connectionStatus }}</div>
+    <div>Connected Relays: {{ connectedRelayCount }}/{{ totalRelayCount }}</div>
+    <button @click="subscribeToEvents" :disabled="!isConnected">
+      Subscribe to Events
+    </button>
+    <div v-if="events.length">
+      <h3>Received Events:</h3>
+      <div v-for="event in events" :key="event.id">
+        {{ event.content }}
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, onMounted, onUnmounted } from 'vue'
+import { useRelayHub } from '@/composables/useRelayHub'
+
+const relayHub = useRelayHub()
+const events = ref<any[]>([])
+let unsubscribe: (() => void) | null = null
+
+const { isConnected, connectionStatus, connectedRelayCount, totalRelayCount } = relayHub
+
+const subscribeToEvents = async () => {
+  if (!relayHub.isConnected.value) {
+    await relayHub.connect()
+  }
+  
+  unsubscribe = relayHub.subscribe({
+    id: 'my-component-events',
+    filters: [
+      {
+        kinds: [1], // Text notes
+        limit: 10
+      }
+    ],
+    onEvent: (event) => {
+      events.value.push(event)
+    }
+  })
+}
+
+onUnmounted(() => {
+  if (unsubscribe) {
+    unsubscribe()
+  }
+})
+</script>
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Not Established**
+   - Check if relay hub is initialized in App.vue
+   - Verify relay URLs in configuration
+   - Check browser console for connection errors
+
+2. **Subscriptions Not Working**
+   - Ensure connection is established before subscribing
+   - Verify subscription filters are correct
+   - Check if unsubscribe function is called prematurely
+
+3. **Performance Issues**
+   - Monitor number of active subscriptions
+   - Use appropriate filter limits
+   - Clean up unused subscriptions
+
+### Debug Tools
+
+The relay hub provides several debugging capabilities:
+
+```typescript
+// Check connection status
+console.log('Connected:', relayHub.isConnected.value)
+console.log('Relay count:', relayHub.totalRelayCount)
+
+// Monitor relay health
+console.log('Health:', relayHub.connectionHealth.value)
+
+// Check specific relay status
+const status = relayHub.getRelayStatus('wss://relay.example.com')
+console.log('Relay status:', status)
+```
+
+## Conclusion
+
+The central relay hub architecture provides a robust, efficient, and maintainable way to manage Nostr relay connections across the Ario application. By following the integration patterns outlined in this document, components can easily leverage the relay hub's capabilities while maintaining clean separation of concerns and optimal performance.
+
+For questions or issues with relay hub integration, refer to the existing implementations in `useNostrChat.ts` and `useMarket.ts` as reference examples.