diff --git a/paystell-frontend/src/app/api/deposit/[id]/route.ts b/paystell-frontend/src/app/api/deposit/[id]/route.ts
new file mode 100644
index 0000000..9667842
--- /dev/null
+++ b/paystell-frontend/src/app/api/deposit/[id]/route.ts
@@ -0,0 +1,158 @@
+import { NextResponse, NextRequest } from "next/server";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { DepositRequest } from "@/lib/types/deposit";
+
+import { depositStore } from "../deposit-store";
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  try {
+    // 1. Authentication check
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+      return NextResponse.json(
+        { message: "Authentication required" },
+        { status: 401 }
+      );
+    }
+
+    const { id } = params;
+
+    // 2. Get deposit request
+    const deposit = depositStore.get(id);
+    if (!deposit) {
+      return NextResponse.json(
+        { message: "Deposit request not found" },
+        { status: 404 }
+      );
+    }
+
+    // 3. Check if user has access to this deposit
+    if (deposit.ownerId !== session.user.id) {
+      return NextResponse.json(
+        { message: "Access denied" },
+        { status: 403 }
+      );
+    }
+
+    return NextResponse.json({
+      success: true,
+      deposit,
+    });
+  } catch (error: unknown) {
+    console.error("Deposit retrieval error:", error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to retrieve deposit";
+    return NextResponse.json({ message: errorMessage }, { status: 500 });
+  }
+}
+
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  try {
+    // 1. Authentication check
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+      return NextResponse.json(
+        { message: "Authentication required" },
+        { status: 401 }
+      );
+    }
+
+    const { id } = params;
+    const updates = await request.json();
+
+    // 2. Get existing deposit request
+    const existingDeposit = depositStore.get(id);
+    if (!existingDeposit) {
+      return NextResponse.json(
+        { message: "Deposit request not found" },
+        { status: 404 }
+      );
+    }
+
+    // 3. Check if user has access to this deposit
+    if (existingDeposit.ownerId !== session.user.id) {
+      return NextResponse.json(
+        { message: "Access denied" },
+        { status: 403 }
+      );
+    }
+
+    // 4. Validate updates
+    const allowedUpdates = ["status", "transactionHash", "confirmedAt"];
+    const validUpdates: Partial<DepositRequest> = {};
+
+    for (const [key, value] of Object.entries(updates)) {
+      if (allowedUpdates.includes(key)) {
+        (validUpdates as Record<string, unknown>)[key] = value;
+      }
+    }
+
+    // 5. Update deposit request
+    const updatedDeposit = depositStore.update(id, validUpdates);
+
+    return NextResponse.json({
+      success: true,
+      deposit: updatedDeposit,
+    });
+  } catch (error: unknown) {
+    console.error("Deposit update error:", error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to update deposit";
+    return NextResponse.json({ message: errorMessage }, { status: 500 });
+  }
+}
+
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  try {
+    // 1. Authentication check
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+      return NextResponse.json(
+        { message: "Authentication required" },
+        { status: 401 }
+      );
+    }
+
+    const { id } = params;
+
+    // 2. Get existing deposit request
+    const existingDeposit = depositStore.get(id);
+    if (!existingDeposit) {
+      return NextResponse.json(
+        { message: "Deposit request not found" },
+        { status: 404 }
+      );
+    }
+
+    // 3. Check if user has access to this deposit
+    if (existingDeposit.ownerId !== session.user.id) {
+      return NextResponse.json(
+        { message: "Access denied" },
+        { status: 403 }
+      );
+    }
+
+    // 4. Delete deposit request
+    depositStore.delete(id);
+
+    return NextResponse.json({
+      success: true,
+      message: "Deposit request deleted",
+    });
+  } catch (error: unknown) {
+    console.error("Deposit deletion error:", error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to delete deposit";
+    return NextResponse.json({ message: errorMessage }, { status: 500 });
+  }
+}
diff --git a/paystell-frontend/src/app/api/deposit/deposit-store.ts b/paystell-frontend/src/app/api/deposit/deposit-store.ts
new file mode 100644
index 0000000..44b71b3
--- /dev/null
+++ b/paystell-frontend/src/app/api/deposit/deposit-store.ts
@@ -0,0 +1,39 @@
+import { DepositRequest } from "@/lib/types/deposit";
+
+// Shared in-memory store for deposit requests
+// In production, use a database
+export const depositRequests = new Map<string, DepositRequest>();
+
+// Helper functions for deposit management
+export const depositStore = {
+  create: (id: string, deposit: DepositRequest) => {
+    depositRequests.set(id, deposit);
+    return deposit;
+  },
+
+  get: (id: string) => {
+    return depositRequests.get(id);
+  },
+
+  update: (id: string, updates: Partial<DepositRequest>) => {
+    const existing = depositRequests.get(id);
+    if (!existing) return null;
+    
+    const updated = { ...existing, ...updates };
+    depositRequests.set(id, updated);
+    return updated;
+  },
+
+  delete: (id: string) => {
+    return depositRequests.delete(id);
+  },
+
+  getAll: () => {
+    return Array.from(depositRequests.values());
+  },
+
+  getByUser: (userId: string) => {
+    return Array.from(depositRequests.values())
+      .filter(deposit => deposit.ownerId === userId);
+  }
+};
diff --git a/paystell-frontend/src/app/api/deposit/monitor/route.ts b/paystell-frontend/src/app/api/deposit/monitor/route.ts
new file mode 100644
index 0000000..0224d6c
--- /dev/null
+++ b/paystell-frontend/src/app/api/deposit/monitor/route.ts
@@ -0,0 +1,200 @@
+import { NextResponse, NextRequest } from "next/server";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { DepositMonitoringConfig } from "@/lib/types/deposit";
+import { isValidStellarAddress } from "@/lib/deposit/deposit-utils";
+
+// In-memory store for monitoring configurations per user
+// In production, use a database
+const monitoringConfigs = new Map<string, Map<string, DepositMonitoringConfig>>();
+
+export async function POST(request: NextRequest) {
+  try {
+    // 1. Authentication check
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+      return NextResponse.json(
+        { message: "Authentication required" },
+        { status: 401 }
+      );
+    }
+
+    const { address, asset, minAmount, maxAmount, memo } = await request.json();
+
+    // 2. Input validation
+    if (!address || !asset) {
+      return NextResponse.json(
+        { message: "Address and asset are required" },
+        { status: 400 }
+      );
+    }
+
+    // 3. Validate Stellar address
+    if (!isValidStellarAddress(address)) {
+      return NextResponse.json(
+        { message: "Invalid Stellar address" },
+        { status: 400 }
+      );
+    }
+
+    // 4. Validate asset
+    const supportedAssets = ["XLM", "USDC", "USDT"];
+    if (!supportedAssets.includes(asset)) {
+      return NextResponse.json(
+        { message: "Unsupported asset" },
+        { status: 400 }
+      );
+    }
+
+    // 5. Validate amounts if provided
+    if (minAmount && (isNaN(parseFloat(minAmount)) || parseFloat(minAmount) <= 0)) {
+      return NextResponse.json(
+        { message: "Invalid minimum amount" },
+        { status: 400 }
+      );
+    }
+
+    if (maxAmount && (isNaN(parseFloat(maxAmount)) || parseFloat(maxAmount) <= 0)) {
+      return NextResponse.json(
+        { message: "Invalid maximum amount" },
+        { status: 400 }
+      );
+    }
+
+    if (minAmount && maxAmount && parseFloat(minAmount) > parseFloat(maxAmount)) {
+      return NextResponse.json(
+        { message: "Minimum amount cannot be greater than maximum amount" },
+        { status: 400 }
+      );
+    }
+
+    // 6. Create monitoring configuration
+    const config: DepositMonitoringConfig = {
+      address,
+      asset,
+      minAmount: minAmount || undefined,
+      maxAmount: maxAmount || undefined,
+      memo: memo || undefined,
+    };
+
+    // 7. Store monitoring configuration per user
+    const userId = session.user.id;
+    const key = `${address}_${asset}`;
+    
+    if (!monitoringConfigs.has(userId)) {
+      monitoringConfigs.set(userId, new Map());
+    }
+    
+    monitoringConfigs.get(userId)!.set(key, config);
+
+    return NextResponse.json({
+      success: true,
+      config,
+      message: "Monitoring started",
+    });
+  } catch (error: unknown) {
+    console.error("Monitoring setup error:", error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to setup monitoring";
+    return NextResponse.json({ message: errorMessage }, { status: 500 });
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    // 1. Authentication check
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+      return NextResponse.json(
+        { message: "Authentication required" },
+        { status: 401 }
+      );
+    }
+
+    const { searchParams } = new URL(request.url);
+    const address = searchParams.get("address");
+    const asset = searchParams.get("asset");
+
+    // 2. Get monitoring configurations for this user only
+    const userId = session.user.id;
+    const userConfigs = monitoringConfigs.get(userId) || new Map();
+    let configs = Array.from(userConfigs.values());
+
+    // 3. Filter by address if provided
+    if (address) {
+      configs = configs.filter(config => config.address === address);
+    }
+
+    // 4. Filter by asset if provided
+    if (asset) {
+      configs = configs.filter(config => config.asset === asset);
+    }
+
+    return NextResponse.json({
+      success: true,
+      configs,
+      total: configs.length,
+    });
+  } catch (error: unknown) {
+    console.error("Monitoring retrieval error:", error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to retrieve monitoring configs";
+    return NextResponse.json({ message: errorMessage }, { status: 500 });
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  try {
+    // 1. Authentication check
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+      return NextResponse.json(
+        { message: "Authentication required" },
+        { status: 401 }
+      );
+    }
+
+    const { searchParams } = new URL(request.url);
+    const address = searchParams.get("address");
+    const asset = searchParams.get("asset");
+
+    // 2. Input validation
+    if (!address || !asset) {
+      return NextResponse.json(
+        { message: "Address and asset are required" },
+        { status: 400 }
+      );
+    }
+
+    // 3. Remove monitoring configuration for this user only
+    const userId = session.user.id;
+    const key = `${address}_${asset}`;
+    
+    const userConfigs = monitoringConfigs.get(userId);
+    if (!userConfigs) {
+      return NextResponse.json(
+        { message: "Monitoring configuration not found" },
+        { status: 404 }
+      );
+    }
+    
+    const deleted = userConfigs.delete(key);
+
+    if (!deleted) {
+      return NextResponse.json(
+        { message: "Monitoring configuration not found" },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: "Monitoring stopped",
+    });
+  } catch (error: unknown) {
+    console.error("Monitoring removal error:", error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to remove monitoring";
+    return NextResponse.json({ message: errorMessage }, { status: 500 });
+  }
+}
diff --git a/paystell-frontend/src/app/api/deposit/route.ts b/paystell-frontend/src/app/api/deposit/route.ts
new file mode 100644
index 0000000..10d7565
--- /dev/null
+++ b/paystell-frontend/src/app/api/deposit/route.ts
@@ -0,0 +1,145 @@
+import { NextResponse, NextRequest } from "next/server";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { DepositRequest } from "@/lib/types/deposit";
+import { generateDepositId, calculateDepositExpiration, isValidStellarAddress } from "@/lib/deposit/deposit-utils";
+import { paymentRateLimit } from "@/middleware/rateLimit";
+
+import { depositStore } from "./deposit-store";
+
+export async function POST(request: NextRequest) {
+  try {
+    // Apply rate limiting
+    const rateLimitResponse = paymentRateLimit(request);
+    if (rateLimitResponse) {
+      return rateLimitResponse;
+    }
+
+    // 1. Authentication check
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+      return NextResponse.json(
+        { message: "Authentication required" },
+        { status: 401 }
+      );
+    }
+
+    const { amount, asset, memo, customAddress } = await request.json();
+
+    // 2. Input validation
+    if (!asset) {
+      return NextResponse.json(
+        { message: "Asset is required" },
+        { status: 400 }
+      );
+    }
+
+    // 3. Validate asset
+    const supportedAssets = ["XLM", "USDC", "USDT"];
+    if (!supportedAssets.includes(asset)) {
+      return NextResponse.json(
+        { message: "Unsupported asset" },
+        { status: 400 }
+      );
+    }
+
+    // 4. Validate amount if provided
+    if (amount && (isNaN(parseFloat(amount)) || parseFloat(amount) <= 0)) {
+      return NextResponse.json(
+        { message: "Invalid amount" },
+        { status: 400 }
+      );
+    }
+
+    // 5. Validate custom address if provided
+    if (customAddress && !isValidStellarAddress(customAddress)) {
+      return NextResponse.json(
+        { message: "Invalid Stellar address" },
+        { status: 400 }
+      );
+    }
+
+    // 6. Validate custom address is provided
+    if (!customAddress) {
+      return NextResponse.json(
+        { message: "Deposit address is required" },
+        { status: 400 }
+      );
+    }
+
+    // 7. Create deposit request
+    const depositRequest: DepositRequest = {
+      id: generateDepositId(),
+      ownerId: session.user.id,
+      address: customAddress,
+      amount: amount || undefined,
+      asset,
+      memo: memo || undefined,
+      status: "pending",
+      createdAt: new Date().toISOString(),
+      expiresAt: calculateDepositExpiration(),
+    };
+
+    // 8. Store deposit request
+    depositStore.create(depositRequest.id, depositRequest);
+
+    return NextResponse.json({
+      success: true,
+      deposit: depositRequest,
+    });
+  } catch (error: unknown) {
+    console.error("Deposit creation error:", error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to create deposit request";
+    return NextResponse.json({ message: errorMessage }, { status: 500 });
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    // 1. Authentication check
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+      return NextResponse.json(
+        { message: "Authentication required" },
+        { status: 401 }
+      );
+    }
+
+    const { searchParams } = new URL(request.url);
+    const requestedUserId = searchParams.get("userId");
+    const status = searchParams.get("status");
+
+    // 2. Security check - prevent access to other users' deposits
+    if (requestedUserId && requestedUserId !== session.user.id) {
+      return NextResponse.json(
+        { message: "Access denied" },
+        { status: 403 }
+      );
+    }
+
+    const targetAddress = requestedUserId ?? session.user.id;
+
+    // 3. Get deposits for user
+    let userDeposits = depositStore.getByUser(targetAddress);
+
+    // 4. Filter by status if provided
+    if (status) {
+      userDeposits = userDeposits.filter(deposit => deposit.status === status);
+    }
+
+    // 5. Sort by creation date (newest first)
+    userDeposits.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+    return NextResponse.json({
+      success: true,
+      deposits: userDeposits,
+      total: userDeposits.length,
+    });
+  } catch (error: unknown) {
+    console.error("Deposit retrieval error:", error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to retrieve deposits";
+    return NextResponse.json({ message: errorMessage }, { status: 500 });
+  }
+}
diff --git a/paystell-frontend/src/app/dashboard/deposit/page.tsx b/paystell-frontend/src/app/dashboard/deposit/page.tsx
new file mode 100644
index 0000000..6958fda
--- /dev/null
+++ b/paystell-frontend/src/app/dashboard/deposit/page.tsx
@@ -0,0 +1,103 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { DepositFlow } from "@/components/deposit/DepositFlow";
+import { OptimisticTransactionList } from "@/components/optimistic/OptimisticTransactionList";
+import { TransactionMonitor } from "@/components/monitoring/TransactionMonitor";
+import { TransactionQueueManager } from "@/components/queue/TransactionQueueManager";
+import { WebSocketStatus } from "@/components/websocket/WebSocketStatus";
+import { useWalletStore } from "@/lib/wallet/wallet-store";
+
+export default function DepositPage() {
+  const { isConnected, publicKey, connectWallet, connecting, error } = useWalletStore();
+  const [activeTab, setActiveTab] = useState("deposit");
+
+  // Initialize monitoring for connected wallet
+  useEffect(() => {
+    if (isConnected && publicKey) {
+      // Start monitoring for XLM deposits
+      // This would typically be done through the monitoring hook
+      console.log(`Monitoring deposits for wallet: ${publicKey}`);
+    }
+  }, [isConnected, publicKey]);
+
+  if (!isConnected) {
+    return (
+      <div className="container mx-auto px-4 py-8 max-w-4xl">
+        <div className="text-center space-y-6">
+          <h1 className="text-2xl font-bold">Deposit Funds</h1>
+          <p className="text-muted-foreground">
+            Please connect your Stellar wallet to access deposit features
+          </p>
+          <button
+            onClick={connectWallet}
+            disabled={connecting}
+            className="bg-primary text-primary-foreground px-6 py-3 rounded-lg hover:bg-primary/90 disabled:opacity-50 disabled:cursor-not-allowed"
+          >
+            {connecting ? "Connecting..." : "Connect Wallet"}
+          </button>
+          {error && (
+            <p className="text-red-500 text-sm">{error}</p>
+          )}
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="container mx-auto px-4 py-8 max-w-6xl">
+      <div className="mb-6">
+        <h1 className="text-2xl font-bold">Deposit & Transaction Management</h1>
+        <p className="text-muted-foreground">
+          Manage your deposits, monitor transactions, and track optimistic updates
+        </p>
+      </div>
+
+      <Tabs value={activeTab} onValueChange={setActiveTab} className="space-y-6">
+        <TabsList className="grid w-full grid-cols-5">
+          <TabsTrigger value="deposit" className="flex items-center gap-2">
+            <span className="hidden sm:inline">Deposit</span>
+            <span className="sm:hidden">💰</span>
+          </TabsTrigger>
+          <TabsTrigger value="optimistic" className="flex items-center gap-2">
+            <span className="hidden sm:inline">Optimistic</span>
+            <span className="sm:hidden">⚡</span>
+          </TabsTrigger>
+          <TabsTrigger value="monitor" className="flex items-center gap-2">
+            <span className="hidden sm:inline">Monitor</span>
+            <span className="sm:hidden">👁️</span>
+          </TabsTrigger>
+          <TabsTrigger value="queue" className="flex items-center gap-2">
+            <span className="hidden sm:inline">Queue</span>
+            <span className="sm:hidden">📋</span>
+          </TabsTrigger>
+          <TabsTrigger value="websocket" className="flex items-center gap-2">
+            <span className="hidden sm:inline">WebSocket</span>
+            <span className="sm:hidden">🔌</span>
+          </TabsTrigger>
+        </TabsList>
+
+        <TabsContent value="deposit" className="space-y-6">
+          <DepositFlow />
+        </TabsContent>
+
+        <TabsContent value="optimistic" className="space-y-6">
+          <OptimisticTransactionList />
+        </TabsContent>
+
+        <TabsContent value="monitor" className="space-y-6">
+          <TransactionMonitor />
+        </TabsContent>
+
+        <TabsContent value="queue" className="space-y-6">
+          <TransactionQueueManager />
+        </TabsContent>
+
+        <TabsContent value="websocket" className="space-y-6">
+          <WebSocketStatus />
+        </TabsContent>
+      </Tabs>
+    </div>
+  );
+}
diff --git a/paystell-frontend/src/app/layout.tsx b/paystell-frontend/src/app/layout.tsx
index 3ca58a9..eb82437 100644
--- a/paystell-frontend/src/app/layout.tsx
+++ b/paystell-frontend/src/app/layout.tsx
@@ -1,18 +1,18 @@
-import type { Metadata } from 'next';
-import { Inter } from 'next/font/google';
-import './globals.css';
-import { AuthProvider } from '@/providers/AuthProvider';
-import { ThemeProvider } from 'next-themes';
-import { WalletProvider } from '@/providers/useWalletProvider';
-import { Toaster } from '@/components/ui/sonner';
-import { ErrorBoundary } from '@/components/ErrorBoundary';
-import { OfflineBanner, OnlineBanner } from '@/components/OfflineBanner';
+import type { Metadata } from "next";
+import { Inter } from "next/font/google";
+import "./globals.css";
+import { AuthProvider } from "@/providers/AuthProvider";
+import { ThemeProvider } from "next-themes";
+import { WalletProvider } from "@/providers/useWalletProvider";
+import { Toaster } from "@/components/ui/sonner";
+import { ErrorBoundary } from "@/components/ErrorBoundary";
+import { OfflineBanner, OnlineBanner } from "@/components/OfflineBanner";
 
-const inter = Inter({ subsets: ['latin'] });
+const inter = Inter({ subsets: ["latin"] });
 
 export const metadata: Metadata = {
-  title: 'PayStell',
-  description: 'Payment Platform',
+  title: "PayStell",
+  description: "Payment Platform",
 };
 
 export default function RootLayout({
@@ -39,3 +39,4 @@ export default function RootLayout({
     </html>
   );
 }
+
diff --git a/paystell-frontend/src/components/dashboard/nav/index.tsx b/paystell-frontend/src/components/dashboard/nav/index.tsx
index d660da9..a46d4da 100644
--- a/paystell-frontend/src/components/dashboard/nav/index.tsx
+++ b/paystell-frontend/src/components/dashboard/nav/index.tsx
@@ -1,15 +1,15 @@
 'use client';
 
-import { cn } from '@/lib/utils';
-import type { NavProps } from './types';
-import { MobileTrigger } from './mobile-trigger';
-import { NavItem } from './nav-item';
-import { navStyles } from './styles';
-import { Logo } from '@/components/dashboard/nav/Logo';
-import { useAuth } from '@/providers/AuthProvider';
-import { useRouter } from 'next/navigation';
-import { IoLogOutOutline } from 'react-icons/io5';
-import { useEffect, useCallback } from 'react';
+import { cn } from "@/lib/utils";
+import type { NavProps } from "./types";
+import { MobileTrigger } from "./mobile-trigger";
+import { NavItem } from "./nav-item";
+import { navStyles } from "./styles";
+import { Logo } from "@/components/dashboard/nav/Logo";
+import { useAuth } from "@/providers/AuthProvider";
+import { useRouter } from "next/navigation";
+import { IoLogOutOutline } from "react-icons/io5";
+import { useEffect, useCallback } from "react";
 
 export function Nav({
   items,
diff --git a/paystell-frontend/src/components/deposit/DepositFlow.tsx b/paystell-frontend/src/components/deposit/DepositFlow.tsx
new file mode 100644
index 0000000..0fa74cd
--- /dev/null
+++ b/paystell-frontend/src/components/deposit/DepositFlow.tsx
@@ -0,0 +1,258 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { ArrowLeft, Download, Clock, QrCode } from "lucide-react";
+import { DepositForm } from "./DepositForm";
+import { DepositQRCode } from "./DepositQRCode";
+import { DepositHistory } from "./DepositHistory";
+import { DepositRequest, DepositTransaction } from "@/lib/types/deposit";
+import { useWalletStore } from "@/lib/wallet/wallet-store";
+import { toast } from "sonner";
+
+interface DepositFlowProps {
+  className?: string;
+}
+
+export function DepositFlow({ className }: DepositFlowProps) {
+  const { isConnected, publicKey } = useWalletStore();
+  const [deposits, setDeposits] = useState<DepositRequest[]>([]);
+  const [transactions, setTransactions] = useState<DepositTransaction[]>([]);
+  const [activeDeposit, setActiveDeposit] = useState<DepositRequest | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  // Load deposits and transactions from localStorage on mount
+  useEffect(() => {
+    loadDeposits();
+    loadTransactions();
+  }, []);
+
+  const loadDeposits = () => {
+    try {
+      const stored = localStorage.getItem("paystell_deposits");
+      if (stored) {
+        setDeposits(JSON.parse(stored));
+      }
+    } catch (error) {
+      console.error("Error loading deposits:", error);
+    }
+  };
+
+  const loadTransactions = () => {
+    try {
+      const stored = localStorage.getItem("paystell_deposit_transactions");
+      if (stored) {
+        setTransactions(JSON.parse(stored));
+      }
+    } catch (error) {
+      console.error("Error loading transactions:", error);
+    }
+  };
+
+  const saveDeposits = (newDeposits: DepositRequest[]) => {
+    try {
+      localStorage.setItem("paystell_deposits", JSON.stringify(newDeposits));
+      setDeposits(newDeposits);
+    } catch (error) {
+      console.error("Error saving deposits:", error);
+    }
+  };
+
+  const saveTransactions = (newTransactions: DepositTransaction[]) => {
+    try {
+      localStorage.setItem("paystell_deposit_transactions", JSON.stringify(newTransactions));
+      setTransactions(newTransactions);
+    } catch (error) {
+      console.error("Error saving transactions:", error);
+    }
+  };
+
+  const handleCreateDeposit = (deposit: DepositRequest) => {
+    const newDeposits = [...deposits, deposit];
+    saveDeposits(newDeposits);
+    setActiveDeposit(deposit);
+    toast.success("Deposit request created successfully");
+  };
+
+  const handleViewDeposit = (deposit: DepositRequest) => {
+    setActiveDeposit(deposit);
+  };
+
+  const handleRefresh = async () => {
+    setIsLoading(true);
+    try {
+      // Simulate API call
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      loadDeposits();
+      loadTransactions();
+      toast.success("Data refreshed");
+    } catch (error) {
+      toast.error("Failed to refresh data");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleBackToForm = () => {
+    setActiveDeposit(null);
+  };
+
+  if (!isConnected) {
+    return (
+      <Card className={className}>
+        <CardContent className="flex items-center justify-center py-12">
+          <div className="text-center space-y-4">
+            <Download className="h-12 w-12 mx-auto text-muted-foreground" />
+            <div>
+              <h3 className="text-lg font-semibold">Connect Your Wallet</h3>
+              <p className="text-muted-foreground">
+                Please connect your Stellar wallet to create deposit requests
+              </p>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (activeDeposit) {
+    return (
+      <div className={className}>
+        <div className="flex items-center gap-4 mb-6">
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={handleBackToForm}
+          >
+            <ArrowLeft className="h-4 w-4 mr-2" />
+            Back
+          </Button>
+          <div>
+            <h2 className="text-xl font-semibold">Deposit Request</h2>
+            <p className="text-sm text-muted-foreground">
+              ID: {activeDeposit.id}
+            </p>
+          </div>
+        </div>
+
+        <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+          <DepositQRCode
+            deposit={activeDeposit}
+            onRefresh={handleRefresh}
+          />
+          
+          <Card>
+            <CardHeader>
+              <CardTitle>Deposit Instructions</CardTitle>
+            </CardHeader>
+            <CardContent className="space-y-4">
+              <div className="space-y-2">
+                <h4 className="font-medium">How to deposit:</h4>
+                <ol className="list-decimal list-inside space-y-1 text-sm text-muted-foreground">
+                  <li>Scan the QR code with your mobile wallet</li>
+                  <li>Or copy the address and send funds manually</li>
+                  <li>Wait for transaction confirmation</li>
+                  <li>Your balance will update automatically</li>
+                </ol>
+              </div>
+
+              <div className="space-y-2">
+                <h4 className="font-medium">Supported Assets:</h4>
+                <ul className="list-disc list-inside space-y-1 text-sm text-muted-foreground">
+                  <li>Stellar Lumens (XLM)</li>
+                  <li>USD Coin (USDC)</li>
+                  <li>Tether (USDT)</li>
+                </ul>
+              </div>
+
+              <div className="space-y-2">
+                <h4 className="font-medium">Important Notes:</h4>
+                <ul className="list-disc list-inside space-y-1 text-sm text-muted-foreground">
+                  <li>Only send supported assets to this address</li>
+                  <li>Minimum deposit: 1 XLM</li>
+                  <li>Deposit requests expire in 24 hours</li>
+                  <li>Transactions may take a few minutes to confirm</li>
+                </ul>
+              </div>
+            </CardContent>
+          </Card>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className={className}>
+      <div className="mb-6">
+        <h2 className="text-2xl font-bold">Deposit Funds</h2>
+        <p className="text-muted-foreground">
+          Create deposit requests and receive funds to your Stellar wallet
+        </p>
+      </div>
+
+      <Tabs defaultValue="create" className="space-y-6">
+        <TabsList className="grid w-full grid-cols-2">
+          <TabsTrigger value="create" className="flex items-center gap-2">
+            <QrCode className="h-4 w-4" />
+            Create Deposit
+          </TabsTrigger>
+          <TabsTrigger value="history" className="flex items-center gap-2">
+            <Clock className="h-4 w-4" />
+            History
+          </TabsTrigger>
+        </TabsList>
+
+        <TabsContent value="create" className="space-y-6">
+          <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+            <DepositForm
+              onCreateDeposit={handleCreateDeposit}
+            />
+            
+            <Card>
+              <CardHeader>
+                <CardTitle>Quick Deposit</CardTitle>
+              </CardHeader>
+              <CardContent className="space-y-4">
+                <div className="space-y-2">
+                  <h4 className="font-medium">Your Wallet Address</h4>
+                  <div className="p-3 bg-muted rounded-lg">
+                    <code className="text-sm font-mono break-all">
+                      {publicKey}
+                    </code>
+                  </div>
+                </div>
+                
+                <div className="space-y-2">
+                  <h4 className="font-medium">Supported Assets</h4>
+                  <div className="flex flex-wrap gap-2">
+                    <span className="px-2 py-1 bg-blue-100 text-blue-800 rounded text-sm">XLM</span>
+                    <span className="px-2 py-1 bg-green-100 text-green-800 rounded text-sm">USDC</span>
+                    <span className="px-2 py-1 bg-purple-100 text-purple-800 rounded text-sm">USDT</span>
+                  </div>
+                </div>
+
+                <div className="space-y-2">
+                  <h4 className="font-medium">Network</h4>
+                  <p className="text-sm text-muted-foreground">
+                    Stellar Testnet
+                  </p>
+                </div>
+              </CardContent>
+            </Card>
+          </div>
+        </TabsContent>
+
+        <TabsContent value="history" className="space-y-6">
+          <DepositHistory
+            deposits={deposits}
+            transactions={transactions}
+            onRefresh={handleRefresh}
+            onViewDeposit={handleViewDeposit}
+          />
+        </TabsContent>
+      </Tabs>
+    </div>
+  );
+}
diff --git a/paystell-frontend/src/components/deposit/DepositForm.tsx b/paystell-frontend/src/components/deposit/DepositForm.tsx
new file mode 100644
index 0000000..77d80cd
--- /dev/null
+++ b/paystell-frontend/src/components/deposit/DepositForm.tsx
@@ -0,0 +1,229 @@
+"use client";
+
+import { useState } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Textarea } from "@/components/ui/textarea";
+import { Switch } from "@/components/ui/switch";
+import { Download, QrCode } from "lucide-react";
+import { DepositRequest } from "@/lib/types/deposit";
+import { generateDepositId, calculateDepositExpiration, isValidStellarAddress } from "@/lib/deposit/deposit-utils";
+import { useWalletStore } from "@/lib/wallet/wallet-store";
+import { toast } from "sonner";
+
+interface DepositFormProps {
+  onCreateDeposit: (deposit: DepositRequest) => void;
+  onCancel?: () => void;
+  className?: string;
+}
+
+const SUPPORTED_ASSETS = [
+  { value: "XLM", label: "Stellar Lumens (XLM)" },
+  { value: "USDC", label: "USD Coin (USDC)" },
+  { value: "USDT", label: "Tether (USDT)" },
+];
+
+export function DepositForm({ onCreateDeposit, onCancel, className }: DepositFormProps) {
+  const { publicKey, isConnected } = useWalletStore();
+  const [formData, setFormData] = useState({
+    amount: "",
+    asset: "XLM",
+    memo: "",
+    customAddress: "",
+    useCustomAddress: false,
+  });
+  const [isCreating, setIsCreating] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    
+    if (!formData.useCustomAddress && (!isConnected || !publicKey)) {
+      toast.error("Please connect your wallet first");
+      return;
+    }
+
+    setIsCreating(true);
+
+    try {
+      const depositAddress = formData.useCustomAddress 
+        ? formData.customAddress 
+        : publicKey;
+
+      if (!depositAddress || !isValidStellarAddress(depositAddress)) {
+        toast.error("Invalid Stellar address");
+        return;
+      }
+
+      const deposit: DepositRequest = {
+        id: generateDepositId(),
+        ownerId: "mock-user", // This will be replaced by the API
+        address: depositAddress,
+        amount: formData.amount || undefined,
+        asset: formData.asset,
+        memo: formData.memo || undefined,
+        status: "pending",
+        createdAt: new Date().toISOString(),
+        expiresAt: calculateDepositExpiration(),
+      };
+
+      onCreateDeposit(deposit);
+      
+      // Reset form
+      setFormData({
+        amount: "",
+        asset: "XLM",
+        memo: "",
+        customAddress: "",
+        useCustomAddress: false,
+      });
+    } catch (error) {
+      console.error("Error creating deposit:", error);
+      toast.error("Failed to create deposit request");
+    } finally {
+      setIsCreating(false);
+    }
+  };
+
+  const handleInputChange = (field: string, value: string | boolean) => {
+    setFormData(prev => ({
+      ...prev,
+      [field]: value,
+    }));
+  };
+
+  return (
+    <Card className={className}>
+      <CardHeader>
+        <CardTitle className="flex items-center gap-2">
+          <Download className="h-5 w-5" />
+          Create Deposit Request
+        </CardTitle>
+      </CardHeader>
+      <CardContent>
+        <form onSubmit={handleSubmit} className="space-y-4">
+          {/* Asset Selection */}
+          <div className="space-y-2">
+            <Label htmlFor="asset">Asset</Label>
+            <Select
+              value={formData.asset}
+              onValueChange={(value) => handleInputChange("asset", value)}
+            >
+              <SelectTrigger>
+                <SelectValue placeholder="Select asset" />
+              </SelectTrigger>
+              <SelectContent>
+                {SUPPORTED_ASSETS.map((asset) => (
+                  <SelectItem key={asset.value} value={asset.value}>
+                    {asset.label}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          {/* Amount Input */}
+          <div className="space-y-2">
+            <Label htmlFor="amount">Amount (Optional)</Label>
+            <Input
+              id="amount"
+              type="number"
+              placeholder="Enter amount"
+              value={formData.amount}
+              onChange={(e) => handleInputChange("amount", e.target.value)}
+              step="0.0000001"
+              min="0"
+            />
+            <p className="text-xs text-muted-foreground">
+              Leave empty to allow any amount
+            </p>
+          </div>
+
+          {/* Memo Input */}
+          <div className="space-y-2">
+            <Label htmlFor="memo">Memo (Optional)</Label>
+            <Textarea
+              id="memo"
+              placeholder="Enter memo"
+              value={formData.memo}
+              onChange={(e) => handleInputChange("memo", e.target.value)}
+              rows={2}
+            />
+          </div>
+
+          {/* Custom Address Toggle */}
+          <div className="flex items-center space-x-2">
+            <Switch
+              id="use-custom-address"
+              checked={formData.useCustomAddress}
+              onCheckedChange={(checked) => handleInputChange("useCustomAddress", checked)}
+            />
+            <Label htmlFor="use-custom-address">Use custom address</Label>
+          </div>
+
+          {/* Custom Address Input */}
+          {formData.useCustomAddress && (
+            <div className="space-y-2">
+              <Label htmlFor="custom-address">Custom Address</Label>
+              <Input
+                id="custom-address"
+                type="text"
+                placeholder="Enter Stellar address"
+                value={formData.customAddress}
+                onChange={(e) => handleInputChange("customAddress", e.target.value)}
+                className="font-mono"
+              />
+            </div>
+          )}
+
+          {/* Current Wallet Address Display */}
+          {!formData.useCustomAddress && isConnected && publicKey && (
+            <div className="space-y-2">
+              <Label>Deposit Address</Label>
+              <Input
+                value={publicKey}
+                readOnly
+                className="font-mono text-sm"
+              />
+              <p className="text-xs text-muted-foreground">
+                Using your connected wallet address
+              </p>
+            </div>
+          )}
+
+          {/* Submit Buttons */}
+          <div className="flex gap-2 pt-4">
+            <Button
+              type="submit"
+              disabled={isCreating || (!formData.useCustomAddress && !isConnected)}
+              className="flex-1"
+            >
+              {isCreating ? (
+                <>
+                  <QrCode className="h-4 w-4 mr-2 animate-spin" />
+                  Creating...
+                </>
+              ) : (
+                <>
+                  <QrCode className="h-4 w-4 mr-2" />
+                  Generate QR Code
+                </>
+              )}
+            </Button>
+            {onCancel && (
+              <Button
+                type="button"
+                variant="outline"
+                onClick={onCancel}
+              >
+                Cancel
+              </Button>
+            )}
+          </div>
+        </form>
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/paystell-frontend/src/components/deposit/DepositHistory.tsx b/paystell-frontend/src/components/deposit/DepositHistory.tsx
new file mode 100644
index 0000000..b9b0a71
--- /dev/null
+++ b/paystell-frontend/src/components/deposit/DepositHistory.tsx
@@ -0,0 +1,275 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { 
+  Table, 
+  TableBody, 
+  TableCell, 
+  TableHead, 
+  TableHeader, 
+  TableRow 
+} from "@/components/ui/table";
+import { 
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { 
+  Clock, 
+  MoreVertical, 
+  Copy, 
+  ExternalLink,
+  RefreshCw,
+  Eye
+} from "lucide-react";
+import { DepositRequest, DepositTransaction } from "@/lib/types/deposit";
+import { 
+  getDepositStatusColor, 
+  getDepositStatusIcon, 
+  formatDepositAmount,
+  isDepositExpired 
+} from "@/lib/deposit/deposit-utils";
+import { toast } from "sonner";
+
+interface DepositHistoryProps {
+  deposits: DepositRequest[];
+  transactions: DepositTransaction[];
+  onRefresh?: () => void;
+  onViewDeposit?: (deposit: DepositRequest) => void;
+  className?: string;
+}
+
+export function DepositHistory({ 
+  deposits, 
+  transactions, 
+  onRefresh, 
+  onViewDeposit,
+  className 
+}: DepositHistoryProps) {
+  const [isRefreshing, setIsRefreshing] = useState(false);
+  const [selectedTab, setSelectedTab] = useState<"deposits" | "transactions">("deposits");
+
+  const handleRefresh = async () => {
+    if (onRefresh) {
+      setIsRefreshing(true);
+      try {
+        await onRefresh();
+      } finally {
+        setIsRefreshing(false);
+      }
+    }
+  };
+
+  const handleCopyAddress = async (address: string) => {
+    try {
+      await navigator.clipboard.writeText(address);
+      toast.success("Address copied to clipboard");
+    } catch (error) {
+      toast.error("Failed to copy address");
+    }
+  };
+
+  const handleViewOnExplorer = (hash: string) => {
+    const explorerUrl = `https://stellar.expert/explorer/testnet/tx/${hash}`;
+    window.open(explorerUrl, "_blank");
+  };
+
+  const formatDate = (dateString: string) => {
+    return new Date(dateString).toLocaleString();
+  };
+
+  const getStatusBadge = (status: string) => {
+    const colorMap = {
+      pending: "bg-yellow-100 text-yellow-800",
+      completed: "bg-green-100 text-green-800",
+      failed: "bg-red-100 text-red-800",
+      expired: "bg-gray-100 text-gray-800",
+    };
+
+    return (
+      <Badge className={colorMap[status as keyof typeof colorMap] || "bg-gray-100 text-gray-800"}>
+        {getDepositStatusIcon(status as 'pending' | 'completed' | 'failed' | 'expired')} {status}
+      </Badge>
+    );
+  };
+
+  return (
+    <Card className={className}>
+      <CardHeader>
+        <div className="flex items-center justify-between">
+          <CardTitle className="flex items-center gap-2">
+            <Clock className="h-5 w-5" />
+            Deposit History
+          </CardTitle>
+          <div className="flex items-center gap-2">
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={handleRefresh}
+              disabled={isRefreshing}
+            >
+              <RefreshCw className={`h-4 w-4 ${isRefreshing ? 'animate-spin' : ''}`} />
+            </Button>
+          </div>
+        </div>
+        
+        {/* Tab Navigation */}
+        <div className="flex space-x-1 bg-muted p-1 rounded-lg">
+          <Button
+            variant={selectedTab === "deposits" ? "default" : "ghost"}
+            size="sm"
+            onClick={() => setSelectedTab("deposits")}
+            className="flex-1"
+          >
+            Deposit Requests ({deposits.length})
+          </Button>
+          <Button
+            variant={selectedTab === "transactions" ? "default" : "ghost"}
+            size="sm"
+            onClick={() => setSelectedTab("transactions")}
+            className="flex-1"
+          >
+            Transactions ({transactions.length})
+          </Button>
+        </div>
+      </CardHeader>
+      <CardContent>
+        {selectedTab === "deposits" ? (
+          <div className="space-y-4">
+            {deposits.length === 0 ? (
+              <div className="text-center py-8 text-muted-foreground">
+                <Clock className="h-12 w-12 mx-auto mb-4 opacity-50" />
+                <p>No deposit requests yet</p>
+                <p className="text-sm">Create your first deposit request to get started</p>
+              </div>
+            ) : (
+              <Table>
+                <TableHeader>
+                  <TableRow>
+                    <TableHead>ID</TableHead>
+                    <TableHead>Amount</TableHead>
+                    <TableHead>Asset</TableHead>
+                    <TableHead>Status</TableHead>
+                    <TableHead>Created</TableHead>
+                    <TableHead>Expires</TableHead>
+                    <TableHead className="w-[50px]"></TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {deposits.map((deposit) => (
+                    <TableRow key={deposit.id}>
+                      <TableCell className="font-mono text-sm">
+                        {deposit.id.slice(-8)}
+                      </TableCell>
+                      <TableCell>
+                        {deposit.amount ? formatDepositAmount(deposit.amount, deposit.asset) : "Any"}
+                      </TableCell>
+                      <TableCell>{deposit.asset}</TableCell>
+                      <TableCell>
+                        {getStatusBadge(deposit.status)}
+                      </TableCell>
+                      <TableCell className="text-sm">
+                        {formatDate(deposit.createdAt)}
+                      </TableCell>
+                      <TableCell className="text-sm">
+                        {formatDate(deposit.expiresAt)}
+                      </TableCell>
+                      <TableCell>
+                        <DropdownMenu>
+                          <DropdownMenuTrigger asChild>
+                            <Button variant="ghost" size="sm">
+                              <MoreVertical className="h-4 w-4" />
+                            </Button>
+                          </DropdownMenuTrigger>
+                          <DropdownMenuContent align="end">
+                            <DropdownMenuItem onClick={() => onViewDeposit?.(deposit)}>
+                              <Eye className="h-4 w-4 mr-2" />
+                              View Details
+                            </DropdownMenuItem>
+                            <DropdownMenuItem onClick={() => handleCopyAddress(deposit.address)}>
+                              <Copy className="h-4 w-4 mr-2" />
+                              Copy Address
+                            </DropdownMenuItem>
+                          </DropdownMenuContent>
+                        </DropdownMenu>
+                      </TableCell>
+                    </TableRow>
+                  ))}
+                </TableBody>
+              </Table>
+            )}
+          </div>
+        ) : (
+          <div className="space-y-4">
+            {transactions.length === 0 ? (
+              <div className="text-center py-8 text-muted-foreground">
+                <Clock className="h-12 w-12 mx-auto mb-4 opacity-50" />
+                <p>No transactions yet</p>
+                <p className="text-sm">Transactions will appear here once deposits are received</p>
+              </div>
+            ) : (
+              <Table>
+                <TableHeader>
+                  <TableRow>
+                    <TableHead>Hash</TableHead>
+                    <TableHead>Amount</TableHead>
+                    <TableHead>Asset</TableHead>
+                    <TableHead>From</TableHead>
+                    <TableHead>Status</TableHead>
+                    <TableHead>Date</TableHead>
+                    <TableHead className="w-[50px]"></TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {transactions.map((tx) => (
+                    <TableRow key={tx.id}>
+                      <TableCell className="font-mono text-sm">
+                        {tx.hash.slice(0, 8)}...{tx.hash.slice(-8)}
+                      </TableCell>
+                      <TableCell>
+                        {formatDepositAmount(tx.amount, tx.asset)}
+                      </TableCell>
+                      <TableCell>{tx.asset}</TableCell>
+                      <TableCell className="font-mono text-sm">
+                        {tx.from.slice(0, 8)}...{tx.from.slice(-8)}
+                      </TableCell>
+                      <TableCell>
+                        {getStatusBadge(tx.status)}
+                      </TableCell>
+                      <TableCell className="text-sm">
+                        {formatDate(tx.createdAt)}
+                      </TableCell>
+                      <TableCell>
+                        <DropdownMenu>
+                          <DropdownMenuTrigger asChild>
+                            <Button variant="ghost" size="sm">
+                              <MoreVertical className="h-4 w-4" />
+                            </Button>
+                          </DropdownMenuTrigger>
+                          <DropdownMenuContent align="end">
+                            <DropdownMenuItem onClick={() => handleViewOnExplorer(tx.hash)}>
+                              <ExternalLink className="h-4 w-4 mr-2" />
+                              View on Explorer
+                            </DropdownMenuItem>
+                            <DropdownMenuItem onClick={() => handleCopyAddress(tx.hash)}>
+                              <Copy className="h-4 w-4 mr-2" />
+                              Copy Hash
+                            </DropdownMenuItem>
+                          </DropdownMenuContent>
+                        </DropdownMenu>
+                      </TableCell>
+                    </TableRow>
+                  ))}
+                </TableBody>
+              </Table>
+            )}
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/paystell-frontend/src/components/deposit/DepositQRCode.tsx b/paystell-frontend/src/components/deposit/DepositQRCode.tsx
new file mode 100644
index 0000000..a7255fc
--- /dev/null
+++ b/paystell-frontend/src/components/deposit/DepositQRCode.tsx
@@ -0,0 +1,202 @@
+"use client";
+
+import { useState } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { QrCode, Copy, Download, RefreshCw } from "lucide-react";
+import { QRCodeSVG } from "qrcode.react";
+import { toast } from "sonner";
+import { DepositRequest } from "@/lib/types/deposit";
+import { generateDepositQRData, formatDepositAmount } from "@/lib/deposit/deposit-utils";
+
+interface DepositQRCodeProps {
+  deposit: DepositRequest;
+  onRefresh?: () => void;
+  onAmountChange?: (amount: string) => void;
+  className?: string;
+}
+
+export function DepositQRCode({ 
+  deposit, 
+  onRefresh, 
+  onAmountChange,
+  className 
+}: DepositQRCodeProps) {
+  const [showQR, setShowQR] = useState(true);
+  const [customAmount, setCustomAmount] = useState(deposit.amount || "");
+  const [isRefreshing, setIsRefreshing] = useState(false);
+
+  const qrData = generateDepositQRData({
+    ...deposit,
+    amount: customAmount || deposit.amount,
+  });
+
+  const handleCopyAddress = async () => {
+    try {
+      await navigator.clipboard.writeText(deposit.address);
+      toast.success("Address copied to clipboard");
+    } catch (error) {
+      toast.error("Failed to copy address");
+    }
+  };
+
+  const handleCopyQRData = async () => {
+    try {
+      await navigator.clipboard.writeText(qrData);
+      toast.success("Payment URI copied to clipboard");
+    } catch (error) {
+      toast.error("Failed to copy payment URI");
+    }
+  };
+
+  const handleDownloadQR = () => {
+    const canvas = document.querySelector('canvas');
+    if (canvas) {
+      const link = document.createElement('a');
+      link.download = `deposit-qr-${deposit.id}.png`;
+      link.href = canvas.toDataURL();
+      link.click();
+    }
+  };
+
+  const handleRefresh = async () => {
+    if (onRefresh) {
+      setIsRefreshing(true);
+      try {
+        await onRefresh();
+      } finally {
+        setIsRefreshing(false);
+      }
+    }
+  };
+
+  const handleAmountChange = (value: string) => {
+    setCustomAmount(value);
+    if (onAmountChange) {
+      onAmountChange(value);
+    }
+  };
+
+  return (
+    <Card className={className}>
+      <CardHeader>
+        <CardTitle className="flex items-center justify-between">
+          <div className="flex items-center gap-2">
+            <QrCode className="h-5 w-5" />
+            Deposit QR Code
+          </div>
+          <div className="flex gap-2">
+            {onRefresh && (
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={handleRefresh}
+                disabled={isRefreshing}
+              >
+                <RefreshCw className={`h-4 w-4 ${isRefreshing ? 'animate-spin' : ''}`} />
+              </Button>
+            )}
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => setShowQR(!showQR)}
+            >
+              {showQR ? "Hide" : "Show"} QR
+            </Button>
+          </div>
+        </CardTitle>
+      </CardHeader>
+      <CardContent className="space-y-4">
+        {/* Amount Input */}
+        <div className="space-y-2">
+          <Label htmlFor="deposit-amount">Amount (Optional)</Label>
+          <Input
+            id="deposit-amount"
+            type="number"
+            placeholder="Enter amount"
+            value={customAmount}
+            onChange={(e) => handleAmountChange(e.target.value)}
+            step="0.0000001"
+            min="0"
+          />
+          <p className="text-xs text-muted-foreground">
+            Leave empty to allow any amount
+          </p>
+        </div>
+
+        {/* QR Code Display */}
+        {showQR && (
+          <div className="flex flex-col items-center space-y-4">
+            <div className="p-4 bg-white rounded-lg border-2 border-dashed border-gray-200">
+              <QRCodeSVG
+                value={qrData}
+                size={200}
+                level="M"
+                includeMargin
+                className="mx-auto"
+              />
+            </div>
+            
+            <div className="flex gap-2">
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={handleCopyQRData}
+              >
+                <Copy className="h-4 w-4 mr-2" />
+                Copy URI
+              </Button>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={handleDownloadQR}
+              >
+                <Download className="h-4 w-4 mr-2" />
+                Download
+              </Button>
+            </div>
+          </div>
+        )}
+
+        {/* Address Display */}
+        <div className="space-y-2">
+          <Label>Deposit Address</Label>
+          <div className="flex items-center gap-2">
+            <Input
+              value={deposit.address}
+              readOnly
+              className="font-mono text-sm"
+            />
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={handleCopyAddress}
+            >
+              <Copy className="h-4 w-4" />
+            </Button>
+          </div>
+        </div>
+
+        {/* Payment URI Display */}
+        <div className="space-y-2">
+          <Label>Payment URI</Label>
+          <div className="p-3 bg-muted rounded-lg">
+            <code className="text-xs font-mono break-all text-muted-foreground">
+              {qrData}
+            </code>
+          </div>
+        </div>
+
+        {/* Deposit Info */}
+        <div className="text-sm text-muted-foreground space-y-1">
+          <p>Asset: {deposit.asset}</p>
+          {deposit.memo && <p>Memo: {deposit.memo}</p>}
+          <p>Status: {deposit.status}</p>
+          <p>Expires: {new Date(deposit.expiresAt).toLocaleString()}</p>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/paystell-frontend/src/components/deposit/__tests__/DepositFlow.test.tsx b/paystell-frontend/src/components/deposit/__tests__/DepositFlow.test.tsx
new file mode 100644
index 0000000..f985ef8
--- /dev/null
+++ b/paystell-frontend/src/components/deposit/__tests__/DepositFlow.test.tsx
@@ -0,0 +1,216 @@
+import React from 'react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { DepositFlow } from '../DepositFlow';
+import { useWalletStore } from '@/lib/wallet/wallet-store';
+
+// Mock the wallet store
+jest.mock('@/lib/wallet/wallet-store', () => ({
+  useWalletStore: jest.fn(),
+}));
+
+// Mock the toast
+jest.mock('sonner', () => ({
+  toast: {
+    success: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+// Mock localStorage
+const localStorageMock = {
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+  removeItem: jest.fn(),
+  clear: jest.fn(),
+};
+Object.defineProperty(window, 'localStorage', {
+  value: localStorageMock,
+});
+
+describe('DepositFlow', () => {
+  const mockUseWalletStore = useWalletStore as jest.MockedFunction<typeof useWalletStore>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    localStorageMock.getItem.mockReturnValue(null);
+  });
+
+  it('should render deposit form when wallet is connected', () => {
+    mockUseWalletStore.mockReturnValue({
+      isConnected: true,
+      publicKey: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    expect(screen.getByText('Create Deposit Request')).toBeInTheDocument();
+    expect(screen.getByText('Asset')).toBeInTheDocument();
+    expect(screen.getByText('Amount (Optional)')).toBeInTheDocument();
+    expect(screen.getByText('Memo (Optional)')).toBeInTheDocument();
+  });
+
+  it('should show connect wallet message when wallet is not connected', () => {
+    mockUseWalletStore.mockReturnValue({
+      isConnected: false,
+      publicKey: null,
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    expect(screen.getByText('Connect Your Wallet')).toBeInTheDocument();
+    expect(screen.getByText('Please connect your Stellar wallet to create deposit requests')).toBeInTheDocument();
+  });
+
+  it('should display wallet address when connected', () => {
+    const publicKey = 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    
+    mockUseWalletStore.mockReturnValue({
+      isConnected: true,
+      publicKey,
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    expect(screen.getByText(publicKey)).toBeInTheDocument();
+  });
+
+  it('should show supported assets', () => {
+    mockUseWalletStore.mockReturnValue({
+      isConnected: true,
+      publicKey: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    expect(screen.getByText('XLM')).toBeInTheDocument();
+    expect(screen.getByText('USDC')).toBeInTheDocument();
+    expect(screen.getByText('USDT')).toBeInTheDocument();
+  });
+
+  it('should show network information', () => {
+    mockUseWalletStore.mockReturnValue({
+      isConnected: true,
+      publicKey: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    expect(screen.getByText('Stellar Testnet')).toBeInTheDocument();
+  });
+
+  it('should have mobile-responsive design', () => {
+    mockUseWalletStore.mockReturnValue({
+      isConnected: true,
+      publicKey: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    // Check for responsive grid classes
+    const gridElement = screen.getByText('Create Deposit Request').closest('.grid');
+    expect(gridElement).toHaveClass('grid-cols-1', 'lg:grid-cols-2');
+  });
+
+  it('should show tabs for different sections', () => {
+    mockUseWalletStore.mockReturnValue({
+      isConnected: true,
+      publicKey: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    expect(screen.getByText('Create Deposit')).toBeInTheDocument();
+    expect(screen.getByText('History')).toBeInTheDocument();
+  });
+
+  it('should handle form submission', async () => {
+    mockUseWalletStore.mockReturnValue({
+      isConnected: true,
+      publicKey: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    // Fill in the form
+    const amountInput = screen.getByLabelText('Amount (Optional)');
+    fireEvent.change(amountInput, { target: { value: '10.5' } });
+
+    const memoInput = screen.getByLabelText('Memo (Optional)');
+    fireEvent.change(memoInput, { target: { value: 'Test memo' } });
+
+    // Submit the form
+    const submitButton = screen.getByText('Generate QR Code');
+    fireEvent.click(submitButton);
+
+    // Wait for the form to be processed
+    await waitFor(() => {
+      expect(screen.getByText('Creating...')).toBeInTheDocument();
+    });
+  });
+
+  it('should show error when wallet is not connected and form is submitted', async () => {
+    mockUseWalletStore.mockReturnValue({
+      isConnected: false,
+      publicKey: null,
+      connecting: false,
+      error: null,
+      networkType: 'TESTNET',
+      connectWallet: jest.fn(),
+      disconnectWallet: jest.fn(),
+      signTransaction: jest.fn(),
+    });
+
+    render(<DepositFlow />);
+
+    // The form should not be visible when wallet is not connected
+    expect(screen.queryByText('Create Deposit Request')).not.toBeInTheDocument();
+  });
+});
diff --git a/paystell-frontend/src/components/monitoring/TransactionMonitor.tsx b/paystell-frontend/src/components/monitoring/TransactionMonitor.tsx
new file mode 100644
index 0000000..c00d355
--- /dev/null
+++ b/paystell-frontend/src/components/monitoring/TransactionMonitor.tsx
@@ -0,0 +1,299 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Switch } from "@/components/ui/switch";
+import { 
+  Table, 
+  TableBody, 
+  TableCell, 
+  TableHead, 
+  TableHeader, 
+  TableRow 
+} from "@/components/ui/table";
+import { 
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { 
+  Eye, 
+  MoreVertical, 
+  ExternalLink, 
+  Copy, 
+  Trash2,
+  RefreshCw,
+  EyeOff
+} from "lucide-react";
+import { useStellarMonitoring } from "@/hooks/use-stellar-monitoring";
+import { DepositTransaction } from "@/lib/types/deposit";
+import { toast } from "sonner";
+
+interface TransactionMonitorProps {
+  className?: string;
+}
+
+export function TransactionMonitor({ className }: TransactionMonitorProps) {
+  const {
+    isMonitoring,
+    transactions,
+    monitoringStatus,
+    startMonitoring,
+    stopMonitoring,
+    refreshTransactions,
+    clearTransactionHistory,
+    getTransactionsForAddress,
+    getTotalReceived,
+    getRecentTransactions,
+  } = useStellarMonitoring();
+
+  const [selectedAddress, setSelectedAddress] = useState<string | null>(null);
+  const [showAllTransactions, setShowAllTransactions] = useState(true);
+
+  const formatDate = (dateString: string) => {
+    return new Date(dateString).toLocaleString();
+  };
+
+  const handleCopyAddress = async (address: string) => {
+    try {
+      await navigator.clipboard.writeText(address);
+      toast.success("Address copied to clipboard");
+    } catch (error) {
+      toast.error("Failed to copy address");
+    }
+  };
+
+  const handleViewOnExplorer = (hash: string) => {
+    const explorerUrl = `https://stellar.expert/explorer/testnet/tx/${hash}`;
+    window.open(explorerUrl, "_blank");
+  };
+
+  const handleStartMonitoring = (address: string, asset: string) => {
+    startMonitoring(address, asset);
+  };
+
+  const handleStopMonitoring = (address: string, asset: string) => {
+    stopMonitoring(address, asset);
+  };
+
+  const handleClearHistory = () => {
+    if (confirm("Are you sure you want to clear all transaction history?")) {
+      clearTransactionHistory();
+    }
+  };
+
+  const getStatusBadge = (status: string) => {
+    const colorMap = {
+      completed: "bg-green-100 text-green-800",
+      pending: "bg-yellow-100 text-yellow-800",
+      failed: "bg-red-100 text-red-800",
+    };
+
+    return (
+      <Badge className={colorMap[status as keyof typeof colorMap] || "bg-gray-100 text-gray-800"}>
+        {status}
+      </Badge>
+    );
+  };
+
+  const filteredTransactions = showAllTransactions 
+    ? transactions 
+    : selectedAddress 
+      ? getTransactionsForAddress(selectedAddress)
+      : transactions;
+
+  const recentTransactions = getRecentTransactions(24);
+  const totalXLM = getTotalReceived("XLM");
+  const totalUSDC = getTotalReceived("USDC");
+
+  return (
+    <Card className={className}>
+      <CardHeader>
+        <div className="flex items-center justify-between">
+          <CardTitle className="flex items-center gap-2">
+            <Eye className="h-5 w-5" />
+            Transaction Monitor
+          </CardTitle>
+          <div className="flex items-center gap-2">
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={refreshTransactions}
+            >
+              <RefreshCw className="h-4 w-4" />
+            </Button>
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={handleClearHistory}
+            >
+              <Trash2 className="h-4 w-4" />
+            </Button>
+          </div>
+        </div>
+      </CardHeader>
+      <CardContent className="space-y-6">
+        {/* Monitoring Status */}
+        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+          <div className="flex items-center space-x-2">
+            <Switch
+              checked={isMonitoring}
+              disabled
+            />
+            <span className="text-sm">
+              {isMonitoring ? "Monitoring Active" : "Monitoring Inactive"}
+            </span>
+          </div>
+          <div className="text-sm text-muted-foreground">
+            Monitored Addresses: {monitoringStatus.configCount}
+          </div>
+          <div className="text-sm text-muted-foreground">
+            Total Transactions: {transactions.length}
+          </div>
+        </div>
+
+        {/* Summary Stats */}
+        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+          <Card>
+            <CardContent className="pt-4">
+              <div className="text-2xl font-bold">{totalXLM.toFixed(7)}</div>
+              <p className="text-xs text-muted-foreground">XLM Received</p>
+            </CardContent>
+          </Card>
+          <Card>
+            <CardContent className="pt-4">
+              <div className="text-2xl font-bold">{totalUSDC.toFixed(2)}</div>
+              <p className="text-xs text-muted-foreground">USDC Received</p>
+            </CardContent>
+          </Card>
+          <Card>
+            <CardContent className="pt-4">
+              <div className="text-2xl font-bold">{recentTransactions.length}</div>
+              <p className="text-xs text-muted-foreground">Last 24h</p>
+            </CardContent>
+          </Card>
+        </div>
+
+        {/* Address Filter */}
+        {monitoringStatus.addresses.length > 0 && (
+          <div className="space-y-2">
+            <label className="text-sm font-medium">Filter by Address</label>
+            <div className="flex flex-wrap gap-2">
+              <Button
+                variant={showAllTransactions ? "default" : "outline"}
+                size="sm"
+                onClick={() => {
+                  setShowAllTransactions(true);
+                  setSelectedAddress(null);
+                }}
+              >
+                All Addresses
+              </Button>
+              {monitoringStatus.addresses.map((address) => (
+                <Button
+                  key={address}
+                  variant={selectedAddress === address ? "default" : "outline"}
+                  size="sm"
+                  onClick={() => {
+                    setSelectedAddress(address);
+                    setShowAllTransactions(false);
+                  }}
+                >
+                  {address.slice(0, 8)}...{address.slice(-8)}
+                </Button>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* Transactions Table */}
+        <div className="space-y-4">
+          <div className="flex items-center justify-between">
+            <h3 className="text-lg font-semibold">Recent Transactions</h3>
+            <div className="flex items-center space-x-2">
+              <span className="text-sm text-muted-foreground">Show all</span>
+              <Switch
+                checked={showAllTransactions}
+                onCheckedChange={setShowAllTransactions}
+              />
+            </div>
+          </div>
+
+          {filteredTransactions.length === 0 ? (
+            <div className="text-center py-8 text-muted-foreground">
+              <Eye className="h-12 w-12 mx-auto mb-4 opacity-50" />
+              <p>No transactions found</p>
+              <p className="text-sm">Transactions will appear here when deposits are received</p>
+            </div>
+          ) : (
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead>Hash</TableHead>
+                  <TableHead>Amount</TableHead>
+                  <TableHead>Asset</TableHead>
+                  <TableHead>From</TableHead>
+                  <TableHead>To</TableHead>
+                  <TableHead>Status</TableHead>
+                  <TableHead>Date</TableHead>
+                  <TableHead className="w-[50px]"></TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {filteredTransactions.map((transaction) => (
+                  <TableRow key={transaction.id}>
+                    <TableCell className="font-mono text-sm">
+                      {transaction.hash.slice(0, 8)}...{transaction.hash.slice(-8)}
+                    </TableCell>
+                    <TableCell className="font-mono">
+                      {transaction.amount}
+                    </TableCell>
+                    <TableCell>{transaction.asset}</TableCell>
+                    <TableCell className="font-mono text-sm">
+                      {transaction.from.slice(0, 8)}...{transaction.from.slice(-8)}
+                    </TableCell>
+                    <TableCell className="font-mono text-sm">
+                      {transaction.to.slice(0, 8)}...{transaction.to.slice(-8)}
+                    </TableCell>
+                    <TableCell>
+                      {getStatusBadge(transaction.status)}
+                    </TableCell>
+                    <TableCell className="text-sm">
+                      {formatDate(transaction.createdAt)}
+                    </TableCell>
+                    <TableCell>
+                      <DropdownMenu>
+                        <DropdownMenuTrigger asChild>
+                          <Button variant="ghost" size="sm">
+                            <MoreVertical className="h-4 w-4" />
+                          </Button>
+                        </DropdownMenuTrigger>
+                        <DropdownMenuContent align="end">
+                          <DropdownMenuItem onClick={() => handleViewOnExplorer(transaction.hash)}>
+                            <ExternalLink className="h-4 w-4 mr-2" />
+                            View on Explorer
+                          </DropdownMenuItem>
+                          <DropdownMenuItem onClick={() => handleCopyAddress(transaction.hash)}>
+                            <Copy className="h-4 w-4 mr-2" />
+                            Copy Hash
+                          </DropdownMenuItem>
+                          <DropdownMenuItem onClick={() => handleCopyAddress(transaction.from)}>
+                            <Copy className="h-4 w-4 mr-2" />
+                            Copy From Address
+                          </DropdownMenuItem>
+                        </DropdownMenuContent>
+                      </DropdownMenu>
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          )}
+        </div>
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/paystell-frontend/src/components/optimistic/OptimisticTransactionList.tsx b/paystell-frontend/src/components/optimistic/OptimisticTransactionList.tsx
new file mode 100644
index 0000000..f608b7d
--- /dev/null
+++ b/paystell-frontend/src/components/optimistic/OptimisticTransactionList.tsx
@@ -0,0 +1,272 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { 
+  Table, 
+  TableBody, 
+  TableCell, 
+  TableHead, 
+  TableHeader, 
+  TableRow 
+} from "@/components/ui/table";
+import { 
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { 
+  Clock, 
+  CheckCircle, 
+  XCircle, 
+  MoreVertical, 
+  RefreshCw,
+  Trash2,
+  ExternalLink
+} from "lucide-react";
+import { useOptimisticStore } from "@/lib/optimistic/optimistic-store";
+import { OptimisticTransaction } from "@/lib/types/deposit";
+import { toast } from "sonner";
+
+interface OptimisticTransactionListProps {
+  className?: string;
+}
+
+export function OptimisticTransactionList({ className }: OptimisticTransactionListProps) {
+  const { 
+    queue, 
+    isProcessing, 
+    processQueue, 
+    clearCompleted, 
+    clearFailed, 
+    removeTransaction 
+  } = useOptimisticStore();
+  
+  const [selectedTab, setSelectedTab] = useState<keyof typeof queue>("pending");
+
+  const getStatusIcon = (status: OptimisticTransaction['status']) => {
+    switch (status) {
+      case 'pending':
+        return <Clock className="h-4 w-4 text-yellow-500" />;
+      case 'completed':
+        return <CheckCircle className="h-4 w-4 text-green-500" />;
+      case 'failed':
+        return <XCircle className="h-4 w-4 text-red-500" />;
+      default:
+        return <Clock className="h-4 w-4 text-gray-500" />;
+    }
+  };
+
+  const getStatusBadge = (status: OptimisticTransaction['status']) => {
+  const colorMap = {
+    pending: "bg-yellow-100 text-yellow-800",
+    completed: "bg-green-100 text-green-800",
+    failed: "bg-red-100 text-red-800",
+  };
+
+    return (
+      <Badge className={colorMap[status]}>
+        {getStatusIcon(status)} {status}
+      </Badge>
+    );
+  };
+
+  const formatDate = (timestamp: number) => {
+    return new Date(timestamp).toLocaleString();
+  };
+
+  const handleProcessQueue = async () => {
+    try {
+      await processQueue();
+      toast.success("Transaction queue processed");
+    } catch (error) {
+      toast.error("Failed to process queue");
+    }
+  };
+
+  const handleClearCompleted = () => {
+    clearCompleted();
+    toast.success("Completed transactions cleared");
+  };
+
+  const handleClearFailed = () => {
+    clearFailed();
+    toast.success("Failed transactions cleared");
+  };
+
+  const handleRemoveTransaction = (id: string) => {
+    removeTransaction(id);
+    toast.success("Transaction removed");
+  };
+
+  const handleViewOnExplorer = (hash: string) => {
+    const explorerUrl = `https://stellar.expert/explorer/testnet/tx/${hash}`;
+    window.open(explorerUrl, "_blank");
+  };
+
+  const getTabCount = (tab: keyof typeof queue) => {
+    return queue[tab].length;
+  };
+
+  const getTotalCount = () => {
+    return Object.values(queue).reduce((sum, arr) => sum + arr.length, 0);
+  };
+
+  return (
+    <Card className={className}>
+      <CardHeader>
+        <div className="flex items-center justify-between">
+          <CardTitle className="flex items-center gap-2">
+            <RefreshCw className="h-5 w-5" />
+            Optimistic Transactions
+          </CardTitle>
+          <div className="flex items-center gap-2">
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={handleProcessQueue}
+              disabled={isProcessing || queue.pending.length === 0}
+            >
+              <RefreshCw className={`h-4 w-4 ${isProcessing ? 'animate-spin' : ''}`} />
+              Process Queue
+            </Button>
+          </div>
+        </div>
+        
+        {/* Tab Navigation */}
+        <div className="flex space-x-1 bg-muted p-1 rounded-lg">
+          {Object.keys(queue).map((tab) => (
+            <Button
+              key={tab}
+              variant={selectedTab === tab ? "default" : "ghost"}
+              size="sm"
+              onClick={() => setSelectedTab(tab as keyof typeof queue)}
+              className="flex-1"
+            >
+              {tab.charAt(0).toUpperCase() + tab.slice(1)} ({getTabCount(tab as keyof typeof queue)})
+            </Button>
+          ))}
+        </div>
+      </CardHeader>
+      <CardContent>
+        {getTotalCount() === 0 ? (
+          <div className="text-center py-8 text-muted-foreground">
+            <Clock className="h-12 w-12 mx-auto mb-4 opacity-50" />
+            <p>No optimistic transactions</p>
+            <p className="text-sm">Transactions will appear here when you make deposits or withdrawals</p>
+          </div>
+        ) : (
+          <div className="space-y-4">
+            {/* Action Buttons */}
+            <div className="flex gap-2">
+              {queue.completed.length > 0 && (
+                <Button
+                  variant="outline"
+                  size="sm"
+                  onClick={handleClearCompleted}
+                >
+                  Clear Completed ({queue.completed.length})
+                </Button>
+              )}
+              {queue.failed.length > 0 && (
+                <Button
+                  variant="outline"
+                  size="sm"
+                  onClick={handleClearFailed}
+                >
+                  Clear Failed ({queue.failed.length})
+                </Button>
+              )}
+            </div>
+
+            {/* Transactions Table */}
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead>Type</TableHead>
+                  <TableHead>Amount</TableHead>
+                  <TableHead>Asset</TableHead>
+                  <TableHead>Status</TableHead>
+                  <TableHead>Date</TableHead>
+                  <TableHead>Hash</TableHead>
+                  <TableHead className="w-[50px]"></TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {queue[selectedTab].map((transaction) => (
+                  <TableRow key={transaction.id}>
+                    <TableCell>
+                      <Badge variant="outline">
+                        {transaction.type}
+                      </Badge>
+                    </TableCell>
+                    <TableCell className="font-mono">
+                      {transaction.amount}
+                    </TableCell>
+                    <TableCell>{transaction.asset}</TableCell>
+                    <TableCell>
+                      {getStatusBadge(transaction.status)}
+                    </TableCell>
+                    <TableCell className="text-sm">
+                      {formatDate(transaction.timestamp)}
+                    </TableCell>
+                    <TableCell className="font-mono text-sm">
+                      {transaction.transactionHash ? (
+                        <span className="text-blue-600 hover:underline cursor-pointer">
+                          {transaction.transactionHash.slice(0, 8)}...{transaction.transactionHash.slice(-8)}
+                        </span>
+                      ) : (
+                        <span className="text-muted-foreground">-</span>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      <DropdownMenu>
+                        <DropdownMenuTrigger asChild>
+                          <Button variant="ghost" size="sm">
+                            <MoreVertical className="h-4 w-4" />
+                          </Button>
+                        </DropdownMenuTrigger>
+                        <DropdownMenuContent align="end">
+                          {transaction.transactionHash && (
+                            <DropdownMenuItem onClick={() => handleViewOnExplorer(transaction.transactionHash!)}>
+                              <ExternalLink className="h-4 w-4 mr-2" />
+                              View on Explorer
+                            </DropdownMenuItem>
+                          )}
+                          <DropdownMenuItem 
+                            onClick={() => handleRemoveTransaction(transaction.id)}
+                            className="text-red-600"
+                          >
+                            <Trash2 className="h-4 w-4 mr-2" />
+                            Remove
+                          </DropdownMenuItem>
+                        </DropdownMenuContent>
+                      </DropdownMenu>
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+
+            {/* Error Display */}
+            {queue[selectedTab].some(tx => tx.error) && (
+              <div className="space-y-2">
+                <h4 className="font-medium text-red-600">Errors:</h4>
+                {queue[selectedTab]
+                  .filter(tx => tx.error)
+                  .map((transaction) => (
+                    <div key={transaction.id} className="p-2 bg-red-50 border border-red-200 rounded text-sm">
+                      <strong>{transaction.id}:</strong> {transaction.error}
+                    </div>
+                  ))}
+              </div>
+            )}
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/paystell-frontend/src/components/queue/TransactionQueueManager.tsx b/paystell-frontend/src/components/queue/TransactionQueueManager.tsx
new file mode 100644
index 0000000..9c4c3d5
--- /dev/null
+++ b/paystell-frontend/src/components/queue/TransactionQueueManager.tsx
@@ -0,0 +1,351 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { 
+  Table, 
+  TableBody, 
+  TableCell, 
+  TableHead, 
+  TableHeader, 
+  TableRow 
+} from "@/components/ui/table";
+import { 
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { 
+  MoreVertical, 
+  ChevronRight, 
+  ChevronDown, 
+  Trash2, 
+  RefreshCw,
+  CheckCircle,
+  XCircle,
+  Clock,
+  AlertCircle
+} from "lucide-react";
+import { transactionQueue, QueueItem, QueueEvent } from "@/lib/queue/transaction-queue";
+import { toast } from "sonner";
+
+interface TransactionQueueManagerProps {
+  className?: string;
+}
+
+export function TransactionQueueManager({ className }: TransactionQueueManagerProps) {
+  const [queueItems, setQueueItems] = useState<QueueItem[]>([]);
+  const [completedItems, setCompletedItems] = useState<QueueItem[]>([]);
+  const [failedItems, setFailedItems] = useState<QueueItem[]>([]);
+  const [status, setStatus] = useState(transactionQueue.getStatus());
+  const [isProcessing, setIsProcessing] = useState(false);
+
+  // Update queue data
+  const updateQueueData = () => {
+    setQueueItems(transactionQueue.getQueue());
+    setCompletedItems(transactionQueue.getCompleted());
+    setFailedItems(transactionQueue.getFailed());
+    setStatus(transactionQueue.getStatus());
+  };
+
+  // Handle queue events
+  const handleQueueEvent = (event: QueueEvent) => {
+    updateQueueData();
+    
+    switch (event.type) {
+      case 'item_added':
+        toast.success('Transaction added to queue');
+        break;
+      case 'item_completed':
+        toast.success('Transaction completed');
+        break;
+      case 'item_failed':
+        toast.error('Transaction failed');
+        break;
+      case 'item_retry':
+        toast.info('Transaction retrying...');
+        break;
+    }
+  };
+
+  // Subscribe to queue events
+  useEffect(() => {
+    transactionQueue.on('item_added', handleQueueEvent);
+    transactionQueue.on('item_processing', handleQueueEvent);
+    transactionQueue.on('item_completed', handleQueueEvent);
+    transactionQueue.on('item_failed', handleQueueEvent);
+    transactionQueue.on('item_retry', handleQueueEvent);
+    transactionQueue.on('queue_cleared', handleQueueEvent);
+
+    return () => {
+      transactionQueue.off('item_added', handleQueueEvent);
+      transactionQueue.off('item_processing', handleQueueEvent);
+      transactionQueue.off('item_completed', handleQueueEvent);
+      transactionQueue.off('item_failed', handleQueueEvent);
+      transactionQueue.off('item_retry', handleQueueEvent);
+      transactionQueue.off('queue_cleared', handleQueueEvent);
+    };
+  }, []);
+
+  // Initial data load
+  useEffect(() => {
+    updateQueueData();
+  }, []);
+
+  // Update status periodically
+  useEffect(() => {
+    const interval = setInterval(updateQueueData, 1000);
+    return () => clearInterval(interval);
+  }, []);
+
+  const getStatusIcon = (status: string) => {
+    switch (status) {
+      case 'pending':
+        return <Clock className="h-4 w-4 text-yellow-500" />;
+      case 'confirmed':
+        return <CheckCircle className="h-4 w-4 text-green-500" />;
+      case 'failed':
+        return <XCircle className="h-4 w-4 text-red-500" />;
+      default:
+        return <AlertCircle className="h-4 w-4 text-gray-500" />;
+    }
+  };
+
+  const getStatusBadge = (status: string) => {
+    const colorMap = {
+      pending: "bg-yellow-100 text-yellow-800",
+      confirmed: "bg-green-100 text-green-800",
+      failed: "bg-red-100 text-red-800",
+    };
+
+    return (
+      <Badge className={colorMap[status as keyof typeof colorMap] || "bg-gray-100 text-gray-800"}>
+        {getStatusIcon(status)} {status}
+      </Badge>
+    );
+  };
+
+  const formatDate = (timestamp: number) => {
+    return new Date(timestamp).toLocaleString();
+  };
+
+  const handleStartProcessing = () => {
+    transactionQueue.startProcessing();
+    setIsProcessing(true);
+    toast.success('Queue processing started');
+  };
+
+  const handleStopProcessing = () => {
+    transactionQueue.stopProcessing();
+    setIsProcessing(false);
+    toast.info('Queue processing stopped');
+  };
+
+  const handleClearQueue = () => {
+    if (confirm('Are you sure you want to clear the entire queue?')) {
+      transactionQueue.clear();
+      toast.success('Queue cleared');
+    }
+  };
+
+  const handleClearCompleted = () => {
+    transactionQueue.clearCompleted();
+    toast.success('Completed items cleared');
+  };
+
+  const handleClearFailed = () => {
+    transactionQueue.clearFailed();
+    toast.success('Failed items cleared');
+  };
+
+  const handleRetryItem = (id: string) => {
+    const success = transactionQueue.retry(id);
+    if (success) {
+      toast.success('Item retried');
+    } else {
+      toast.error('Failed to retry item');
+    }
+  };
+
+  const handleRemoveItem = (id: string) => {
+    const success = transactionQueue.remove(id);
+    if (success) {
+      toast.success('Item removed');
+    } else {
+      toast.error('Failed to remove item');
+    }
+  };
+
+  const allItems = [...queueItems, ...completedItems, ...failedItems];
+
+  return (
+    <Card className={className}>
+      <CardHeader>
+        <div className="flex items-center justify-between">
+          <CardTitle className="flex items-center gap-2">
+            <Clock className="h-5 w-5" />
+            Transaction Queue
+          </CardTitle>
+          <div className="flex items-center gap-2">
+            {isProcessing ? (
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={handleStopProcessing}
+              >
+                <ChevronDown className="h-4 w-4 mr-2" />
+                Stop
+              </Button>
+            ) : (
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={handleStartProcessing}
+              >
+                <ChevronRight className="h-4 w-4 mr-2" />
+                Start
+              </Button>
+            )}
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={updateQueueData}
+            >
+              <RefreshCw className="h-4 w-4" />
+            </Button>
+          </div>
+        </div>
+      </CardHeader>
+      <CardContent className="space-y-6">
+        {/* Queue Status */}
+        <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+          <div className="text-center">
+            <div className="text-2xl font-bold text-yellow-600">{status.pending}</div>
+            <p className="text-xs text-muted-foreground">Pending</p>
+          </div>
+          <div className="text-center">
+            <div className="text-2xl font-bold text-blue-600">{status.processing}</div>
+            <p className="text-xs text-muted-foreground">Processing</p>
+          </div>
+          <div className="text-center">
+            <div className="text-2xl font-bold text-green-600">{status.completed}</div>
+            <p className="text-xs text-muted-foreground">Completed</p>
+          </div>
+          <div className="text-center">
+            <div className="text-2xl font-bold text-red-600">{status.failed}</div>
+            <p className="text-xs text-muted-foreground">Failed</p>
+          </div>
+        </div>
+
+        {/* Action Buttons */}
+        <div className="flex gap-2">
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={handleClearCompleted}
+            disabled={status.completed === 0}
+          >
+            Clear Completed ({status.completed})
+          </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={handleClearFailed}
+            disabled={status.failed === 0}
+          >
+            Clear Failed ({status.failed})
+          </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={handleClearQueue}
+            disabled={status.total === 0}
+          >
+            <Trash2 className="h-4 w-4 mr-2" />
+            Clear All
+          </Button>
+        </div>
+
+        {/* Queue Items Table */}
+          {allItems.length === 0 ? (
+            <div className="text-center py-8 text-muted-foreground">
+              <Clock className="h-12 w-12 mx-auto mb-4 opacity-50" />
+              <p>No items in queue</p>
+              <p className="text-sm">Transactions will appear here when added to the queue</p>
+            </div>
+        ) : (
+          <Table>
+            <TableHeader>
+              <TableRow>
+                <TableHead>ID</TableHead>
+                <TableHead>Type</TableHead>
+                <TableHead>Amount</TableHead>
+                <TableHead>Asset</TableHead>
+                <TableHead>Status</TableHead>
+                <TableHead>Retries</TableHead>
+                <TableHead>Created</TableHead>
+                <TableHead className="w-[50px]"></TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {allItems.map((item) => (
+                <TableRow key={item.id}>
+                  <TableCell className="font-mono text-sm">
+                    {item.id.slice(-8)}
+                  </TableCell>
+                  <TableCell>
+                    <Badge variant="outline">
+                      {item.transaction.type}
+                    </Badge>
+                  </TableCell>
+                  <TableCell className="font-mono">
+                    {item.transaction.amount}
+                  </TableCell>
+                  <TableCell>{item.transaction.asset}</TableCell>
+                  <TableCell>
+                    {getStatusBadge(item.transaction.status)}
+                  </TableCell>
+                  <TableCell>
+                    <Badge variant="outline">
+                      {item.retries}
+                    </Badge>
+                  </TableCell>
+                  <TableCell className="text-sm">
+                    {formatDate(item.createdAt)}
+                  </TableCell>
+                  <TableCell>
+                    <DropdownMenu>
+                      <DropdownMenuTrigger asChild>
+                        <Button variant="ghost" size="sm">
+                            <MoreVertical className="h-4 w-4" />
+                        </Button>
+                      </DropdownMenuTrigger>
+                      <DropdownMenuContent align="end">
+                        {item.transaction.status === 'failed' && (
+                          <DropdownMenuItem onClick={() => handleRetryItem(item.id)}>
+                            <RefreshCw className="h-4 w-4 mr-2" />
+                            Retry
+                          </DropdownMenuItem>
+                        )}
+                        <DropdownMenuItem 
+                          onClick={() => handleRemoveItem(item.id)}
+                          className="text-red-600"
+                        >
+                          <Trash2 className="h-4 w-4 mr-2" />
+                          Remove
+                        </DropdownMenuItem>
+                      </DropdownMenuContent>
+                    </DropdownMenu>
+                  </TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/paystell-frontend/src/components/websocket/WebSocketStatus.tsx b/paystell-frontend/src/components/websocket/WebSocketStatus.tsx
new file mode 100644
index 0000000..95e738e
--- /dev/null
+++ b/paystell-frontend/src/components/websocket/WebSocketStatus.tsx
@@ -0,0 +1,186 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { 
+  Radio, 
+  X, 
+  RefreshCw, 
+  AlertCircle, 
+  CheckCircle, 
+  Clock 
+} from "lucide-react";
+import { useWebSocket } from "@/hooks/use-websocket";
+import { toast } from "sonner";
+
+interface WebSocketStatusProps {
+  className?: string;
+}
+
+export function WebSocketStatus({ className }: WebSocketStatusProps) {
+  const {
+    isConnected,
+    isConnecting,
+    reconnectAttempts,
+    lastMessage,
+    getConnectionStatus,
+  } = useWebSocket();
+
+  const [status, setStatus] = useState({
+    isConnected: false,
+    isConnecting: false,
+    reconnectAttempts: 0,
+  });
+
+  // Update status periodically
+  useEffect(() => {
+    const updateStatus = () => {
+      const newStatus = getConnectionStatus();
+      setStatus(newStatus);
+    };
+
+    updateStatus();
+    const interval = setInterval(updateStatus, 1000);
+    return () => clearInterval(interval);
+  }, [getConnectionStatus]);
+
+  const getStatusIcon = () => {
+    if (isConnecting) {
+      return <RefreshCw className="h-4 w-4 animate-spin text-yellow-500" />;
+    }
+    
+    if (isConnected) {
+      return <CheckCircle className="h-4 w-4 text-green-500" />;
+    }
+    
+    if (reconnectAttempts > 0) {
+      return <AlertCircle className="h-4 w-4 text-orange-500" />;
+    }
+    
+    return <X className="h-4 w-4 text-red-500" />;
+  };
+
+  const getStatusText = () => {
+    if (isConnecting) {
+      return "Connecting...";
+    }
+    
+    if (isConnected) {
+      return "Connected";
+    }
+    
+    if (reconnectAttempts > 0) {
+      return `Reconnecting (${reconnectAttempts})`;
+    }
+    
+    return "Disconnected";
+  };
+
+  const getStatusBadge = () => {
+    if (isConnected) {
+      return <Badge className="bg-green-100 text-green-800">Online</Badge>;
+    }
+    
+    if (isConnecting) {
+      return <Badge className="bg-yellow-100 text-yellow-800">Connecting</Badge>;
+    }
+    
+    if (reconnectAttempts > 0) {
+      return <Badge className="bg-orange-100 text-orange-800">Reconnecting</Badge>;
+    }
+    
+    return <Badge className="bg-red-100 text-red-800">Offline</Badge>;
+  };
+
+  const formatLastMessage = () => {
+    if (!lastMessage) return "No messages";
+    
+    const time = new Date(lastMessage.timestamp).toLocaleTimeString();
+    return `${lastMessage.type} at ${time}`;
+  };
+
+  const handleRefresh = () => {
+    toast.info("WebSocket status refreshed");
+  };
+
+  return (
+    <Card className={className}>
+      <CardHeader>
+        <CardTitle className="flex items-center justify-between">
+          <div className="flex items-center gap-2">
+            <Radio className="h-5 w-5" />
+            WebSocket Status
+          </div>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={handleRefresh}
+          >
+            <RefreshCw className="h-4 w-4" />
+          </Button>
+        </CardTitle>
+      </CardHeader>
+      <CardContent className="space-y-4">
+        {/* Connection Status */}
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-2">
+            {getStatusIcon()}
+            <span className="font-medium">{getStatusText()}</span>
+          </div>
+          {getStatusBadge()}
+        </div>
+
+        {/* Connection Details */}
+        <div className="space-y-2 text-sm text-muted-foreground">
+          <div className="flex justify-between">
+            <span>Status:</span>
+            <span className="font-mono">
+              {isConnected ? "CONNECTED" : "DISCONNECTED"}
+            </span>
+          </div>
+          
+          <div className="flex justify-between">
+            <span>Reconnect Attempts:</span>
+            <span className="font-mono">{reconnectAttempts}</span>
+          </div>
+          
+          <div className="flex justify-between">
+            <span>Last Message:</span>
+            <span className="font-mono text-xs">
+              {formatLastMessage()}
+            </span>
+          </div>
+        </div>
+
+        {/* Connection Info */}
+        <div className="pt-2 border-t">
+          <div className="text-xs text-muted-foreground space-y-1">
+            <p>Real-time updates for:</p>
+            <ul className="list-disc list-inside space-y-1 ml-2">
+              <li>Transaction confirmations</li>
+              <li>Balance changes</li>
+              <li>Deposit notifications</li>
+              <li>Network status</li>
+            </ul>
+          </div>
+        </div>
+
+        {/* Troubleshooting */}
+        {!isConnected && reconnectAttempts > 2 && (
+          <div className="pt-2 border-t">
+            <div className="text-xs text-muted-foreground space-y-1">
+              <p className="font-medium text-orange-600">Troubleshooting:</p>
+              <ul className="list-disc list-inside space-y-1 ml-2">
+                <li>Check your internet connection</li>
+                <li>Refresh the page</li>
+                <li>Contact support if issue persists</li>
+              </ul>
+            </div>
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/paystell-frontend/src/config/dashboard/nav.ts b/paystell-frontend/src/config/dashboard/nav.ts
index 2a13852..9707fa2 100644
--- a/paystell-frontend/src/config/dashboard/nav.ts
+++ b/paystell-frontend/src/config/dashboard/nav.ts
@@ -1,5 +1,5 @@
-import { Home, Link, HandCoins, Settings, Users, ShieldCheck, ShoppingBag } from 'lucide-react';
-import { Permission, UserRole } from '@/lib/types/user';
+import { Home, Link, HandCoins, Settings, Users, ShieldCheck, ShoppingBag, Download } from "lucide-react";
+import { Permission, UserRole } from "@/lib/types/user";
 
 // Common navigation items for all users
 export const commonNavItems = [
@@ -29,6 +29,12 @@ export const transactionNavItems = [
     icon: HandCoins,
     requiredPermissions: [Permission.VIEW_PAYMENTS],
   },
+  {
+    title: "Deposit",
+    href: "/dashboard/deposit",
+    icon: Download,
+    requiredPermissions: [Permission.CREATE_PAYMENT],
+  },
 ];
 
 // Navigation items for merchants
diff --git a/paystell-frontend/src/hooks/use-optimistic-transactions.ts b/paystell-frontend/src/hooks/use-optimistic-transactions.ts
new file mode 100644
index 0000000..fcd348a
--- /dev/null
+++ b/paystell-frontend/src/hooks/use-optimistic-transactions.ts
@@ -0,0 +1,174 @@
+"use client";
+
+import { useCallback } from "react";
+import { useOptimisticStore } from "@/lib/optimistic/optimistic-store";
+import { OptimisticTransaction } from "@/lib/types/deposit";
+import { toast } from "sonner";
+
+export function useOptimisticTransactions() {
+  const { 
+    addTransaction, 
+    updateTransaction, 
+    removeTransaction, 
+    moveTransaction,
+    processQueue,
+    getTransaction,
+    getTransactionsByStatus,
+    queue,
+    isProcessing
+  } = useOptimisticStore();
+
+  const createDepositTransaction = useCallback((
+    amount: string,
+    asset: string,
+    address: string
+  ) => {
+    const transaction: OptimisticTransaction = {
+      id: `deposit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      type: "deposit",
+      amount,
+      asset,
+      status: "pending",
+      timestamp: Date.now(),
+    };
+
+    addTransaction(transaction);
+    toast.success("Deposit transaction added to queue");
+    return transaction;
+  }, [addTransaction]);
+
+  const createWithdrawTransaction = useCallback((
+    amount: string,
+    asset: string,
+    destination: string
+  ) => {
+    const transaction: OptimisticTransaction = {
+      id: `withdraw_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      type: "withdraw",
+      amount,
+      asset,
+      status: "pending",
+      timestamp: Date.now(),
+    };
+
+    addTransaction(transaction);
+    toast.success("Withdrawal transaction added to queue");
+    return transaction;
+  }, [addTransaction]);
+
+  const resolveSourceQueue = useCallback((id: string): "pending" | "processing" | "completed" | "failed" | null => {
+    const currentQueue = useOptimisticStore.getState().queue;
+    if (currentQueue.pending.some((tx) => tx.id === id)) return "pending";
+    if (currentQueue.processing.some((tx) => tx.id === id)) return "processing";
+    if (currentQueue.completed.some((tx) => tx.id === id)) return "completed";
+    if (currentQueue.failed.some((tx) => tx.id === id)) return "failed";
+    return null;
+  }, []);
+
+  const confirmTransaction = useCallback((id: string, transactionHash: string) => {
+    const source = resolveSourceQueue(id);
+
+    updateTransaction(id, {
+      status: "completed",
+      transactionHash,
+    });
+
+    if (source && source !== "completed") {
+      moveTransaction(id, source, "completed");
+    }
+
+    toast.success("Transaction confirmed");
+  }, [resolveSourceQueue, updateTransaction, moveTransaction]);
+
+  const failTransaction = useCallback((id: string, error: string) => {
+    const source = resolveSourceQueue(id);
+
+    updateTransaction(id, {
+      status: "failed",
+      error,
+    });
+
+    if (source && source !== "failed") {
+      moveTransaction(id, source, "failed");
+    }
+
+    toast.error(`Transaction failed: ${error}`);
+  }, [resolveSourceQueue, updateTransaction, moveTransaction]);
+
+  const retryTransaction = useCallback((id: string) => {
+    const transaction = getTransaction(id);
+    if (transaction && transaction.status === "failed") {
+      updateTransaction(id, {
+        status: "pending",
+        error: undefined,
+      });
+      moveTransaction(id, "failed", "pending");
+      toast.success("Transaction retried");
+    }
+  }, [getTransaction, updateTransaction, moveTransaction]);
+
+  const cancelTransaction = useCallback((id: string) => {
+    const transaction = getTransaction(id);
+    if (transaction && transaction.status === "pending") {
+      removeTransaction(id);
+      toast.success("Transaction cancelled");
+    }
+  }, [getTransaction, removeTransaction]);
+
+  const getPendingTransactions = useCallback(() => {
+    return getTransactionsByStatus("pending");
+  }, [getTransactionsByStatus]);
+
+  const getConfirmedTransactions = useCallback(() => {
+    return getTransactionsByStatus("completed");
+  }, [getTransactionsByStatus]);
+
+  const getFailedTransactions = useCallback(() => {
+    return getTransactionsByStatus("failed");
+  }, [getTransactionsByStatus]);
+
+  const hasPendingTransactions = useCallback(() => {
+    return queue.pending.length > 0;
+  }, [queue.pending.length]);
+
+  const hasProcessingTransactions = useCallback(() => {
+    return queue.processing.length > 0;
+  }, [queue.processing.length]);
+
+  const getTotalPendingAmount = useCallback((asset?: string) => {
+    return queue.pending
+      .filter(tx => !asset || tx.asset === asset)
+      .reduce((sum, tx) => sum + parseFloat(tx.amount), 0);
+  }, [queue.pending]);
+
+  const getTotalConfirmedAmount = useCallback((asset?: string) => {
+    return queue.completed
+      .filter(tx => !asset || tx.asset === asset)
+      .reduce((sum, tx) => sum + parseFloat(tx.amount), 0);
+  }, [queue.completed]);
+
+  return {
+    // State
+    queue,
+    isProcessing,
+    
+    // Actions
+    createDepositTransaction,
+    createWithdrawTransaction,
+    confirmTransaction,
+    failTransaction,
+    retryTransaction,
+    cancelTransaction,
+    processQueue,
+    
+    // Getters
+    getTransaction,
+    getPendingTransactions,
+    getConfirmedTransactions,
+    getFailedTransactions,
+    hasPendingTransactions,
+    hasProcessingTransactions,
+    getTotalPendingAmount,
+    getTotalConfirmedAmount,
+  };
+}
diff --git a/paystell-frontend/src/hooks/use-stellar-monitoring.ts b/paystell-frontend/src/hooks/use-stellar-monitoring.ts
new file mode 100644
index 0000000..f8cc731
--- /dev/null
+++ b/paystell-frontend/src/hooks/use-stellar-monitoring.ts
@@ -0,0 +1,198 @@
+"use client";
+
+import { useEffect, useCallback, useState } from "react";
+import { stellarMonitor } from "@/lib/monitoring/stellar-monitor";
+import { DepositTransaction, DepositMonitoringConfig } from "@/lib/types/deposit";
+import { useOptimisticTransactions } from "./use-optimistic-transactions";
+import { toast } from "sonner";
+
+export function useStellarMonitoring() {
+  const [isMonitoring, setIsMonitoring] = useState(false);
+  const [transactions, setTransactions] = useState<DepositTransaction[]>([]);
+  const [monitoringStatus, setMonitoringStatus] = useState({
+    isMonitoring: false,
+    configCount: 0,
+    addresses: [] as string[],
+  });
+
+  const { confirmTransaction, createDepositTransaction } = useOptimisticTransactions();
+
+  // Load existing transactions on mount
+  useEffect(() => {
+    const existingTransactions = stellarMonitor.getTransactionHistory();
+    setTransactions(existingTransactions);
+  }, []);
+
+  // Update monitoring status
+  useEffect(() => {
+    const updateStatus = () => {
+      const status = stellarMonitor.getMonitoringStatus();
+      setMonitoringStatus(status);
+      setIsMonitoring(status.isMonitoring);
+    };
+
+    updateStatus();
+    const interval = setInterval(updateStatus, 1000);
+    return () => clearInterval(interval);
+  }, []);
+
+  // Start monitoring for an address
+  const startMonitoring = useCallback((
+    address: string,
+    asset: string,
+    options?: {
+      minAmount?: string;
+      maxAmount?: string;
+      memo?: string;
+    }
+  ) => {
+    const config: DepositMonitoringConfig = {
+      address,
+      asset,
+      minAmount: options?.minAmount,
+      maxAmount: options?.maxAmount,
+      memo: options?.memo,
+      callback: (transaction: DepositTransaction) => {
+        // Handle new transaction
+        handleNewTransaction(transaction);
+      },
+    };
+
+    stellarMonitor.addMonitoring(config);
+    toast.success(`Started monitoring ${asset} deposits to ${address.slice(0, 8)}...`);
+  }, []);
+
+  // Stop monitoring for an address
+  const stopMonitoring = useCallback((address: string, asset: string) => {
+    stellarMonitor.removeMonitoring(address, asset);
+    toast.success(`Stopped monitoring ${asset} deposits to ${address.slice(0, 8)}...`);
+  }, []);
+
+  // Handle new transaction
+  const handleNewTransaction = useCallback((transaction: DepositTransaction) => {
+    // Add to transaction list
+    let alreadyHandled = false;
+    setTransactions(prev => {
+      const exists = prev.some(t => t.hash === transaction.hash);
+      if (exists) {
+        alreadyHandled = true;
+        return prev;
+      }
+      
+      return [transaction, ...prev].slice(0, 100); // Keep last 100
+    });
+
+    if (alreadyHandled) {
+      return;
+    }
+
+    // Create optimistic transaction
+    const optimisticTx = createDepositTransaction(
+      transaction.amount,
+      transaction.asset,
+      transaction.to
+    );
+
+    // Confirm the optimistic transaction
+    confirmTransaction(optimisticTx.id, transaction.hash);
+
+    // Show success notification
+    toast.success(
+      `Deposit received: ${transaction.amount} ${transaction.asset}`,
+      {
+        description: `From: ${transaction.from.slice(0, 8)}...${transaction.from.slice(-8)}`,
+        action: {
+          label: "View",
+          onClick: () => {
+            // Could open transaction details modal
+            console.log("View transaction:", transaction);
+          },
+        },
+      }
+    );
+  }, [createDepositTransaction, confirmTransaction]);
+
+  // Get transaction history
+  const getTransactionHistory = useCallback(() => {
+    return stellarMonitor.getTransactionHistory();
+  }, []);
+
+  // Clear transaction history
+  const clearTransactionHistory = useCallback(() => {
+    stellarMonitor.clearTransactionHistory();
+    setTransactions([]);
+    toast.success("Transaction history cleared");
+  }, []);
+
+  // Refresh transactions
+  const refreshTransactions = useCallback(() => {
+    const updatedTransactions = stellarMonitor.getTransactionHistory();
+    setTransactions(updatedTransactions);
+  }, []);
+
+  // Get transactions for a specific address
+  const getTransactionsForAddress = useCallback((address: string) => {
+    return transactions.filter(tx => tx.to === address);
+  }, [transactions]);
+
+  // Get transactions for a specific asset
+  const getTransactionsForAsset = useCallback((asset: string) => {
+    return transactions.filter(tx => tx.asset === asset);
+  }, [transactions]);
+
+  // Get total received amount for an asset
+  const getTotalReceived = useCallback((asset: string, address?: string) => {
+    let filtered = transactions.filter(tx => tx.asset === asset);
+    
+    if (address) {
+      filtered = filtered.filter(tx => tx.to === address);
+    }
+
+    return filtered.reduce((sum, tx) => sum + parseFloat(tx.amount), 0);
+  }, [transactions]);
+
+  // Get recent transactions (last 24 hours)
+  const getRecentTransactions = useCallback((hours: number = 24) => {
+    const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000);
+    return transactions.filter(tx => new Date(tx.createdAt) > cutoff);
+  }, [transactions]);
+
+  // Check if address is being monitored
+  const isAddressMonitored = useCallback((address: string, asset: string) => {
+    const key = `${address}_${asset}`;
+    return monitoringStatus.addresses.includes(key);
+  }, [monitoringStatus.addresses]);
+
+  // Get all monitored addresses
+  const getMonitoredAddresses = useCallback(() => {
+    return monitoringStatus.addresses;
+  }, [monitoringStatus.addresses]);
+
+  // Get monitoring count
+  const getMonitoringCount = useCallback(() => {
+    return monitoringStatus.configCount;
+  }, [monitoringStatus.configCount]);
+
+  return {
+    // State
+    isMonitoring,
+    transactions,
+    monitoringStatus,
+    
+    // Actions
+    startMonitoring,
+    stopMonitoring,
+    refreshTransactions,
+    clearTransactionHistory,
+    
+    // Getters
+    getTransactionHistory,
+    getTransactionsForAddress,
+    getTransactionsForAsset,
+    getTotalReceived,
+    getRecentTransactions,
+    isAddressMonitored,
+    getMonitoredAddresses,
+    getMonitoringCount,
+  };
+}
diff --git a/paystell-frontend/src/hooks/use-websocket.ts b/paystell-frontend/src/hooks/use-websocket.ts
new file mode 100644
index 0000000..8754d9c
--- /dev/null
+++ b/paystell-frontend/src/hooks/use-websocket.ts
@@ -0,0 +1,171 @@
+"use client";
+
+import { useEffect, useCallback, useState } from "react";
+import { websocketClient, WebSocketMessage, TransactionMessage, DepositMessage, BalanceMessage } from "@/lib/websocket/websocket-client";
+import { DepositTransaction } from "@/lib/types/deposit";
+import { useOptimisticTransactions } from "./use-optimistic-transactions";
+import { toast } from "sonner";
+
+export function useWebSocket() {
+  const [isConnected, setIsConnected] = useState(false);
+  const [isConnecting, setIsConnecting] = useState(false);
+  const [reconnectAttempts, setReconnectAttempts] = useState(0);
+  const [lastMessage, setLastMessage] = useState<WebSocketMessage | null>(null);
+
+  const { confirmTransaction, failTransaction } = useOptimisticTransactions();
+
+  // Update connection status
+  useEffect(() => {
+    const updateStatus = () => {
+      const status = websocketClient.getStatus();
+      setIsConnected(status.isConnected);
+      setIsConnecting(status.isConnecting);
+      setReconnectAttempts(status.reconnectAttempts);
+    };
+
+    updateStatus();
+    const interval = setInterval(updateStatus, 1000);
+    return () => clearInterval(interval);
+  }, []);
+
+  // Connect on mount
+  useEffect(() => {
+    const connect = async () => {
+      try {
+        await websocketClient.connect();
+      } catch (error) {
+        console.error('Failed to connect to WebSocket:', error);
+      }
+    };
+
+    connect();
+
+    return () => {
+      websocketClient.disconnect();
+    };
+  }, []);
+
+  // Handle transaction messages
+  const handleTransactionMessage = useCallback((message: WebSocketMessage) => {
+    const transaction = message.data as Record<string, unknown>;
+    
+    // Update optimistic transaction
+    if (transaction.id && transaction.hash) {
+      confirmTransaction(transaction.id as string, transaction.hash as string);
+    }
+    
+    // Show notification
+    toast.success(
+      `Transaction confirmed: ${transaction.amount || 'Unknown'} ${transaction.asset || 'Unknown'}`,
+      {
+        description: transaction.hash ? `Hash: ${(transaction.hash as string).slice(0, 8)}...${(transaction.hash as string).slice(-8)}` : 'Transaction processed',
+      }
+    );
+  }, [confirmTransaction]);
+
+  // Handle deposit messages
+  const handleDepositMessage = useCallback((message: WebSocketMessage) => {
+    const { id, status, transactionHash } = message.data as Record<string, unknown>;
+    
+    if (status === 'completed' && transactionHash) {
+      confirmTransaction(id as string, transactionHash as string);
+      toast.success('Deposit completed successfully');
+    } else if (status === 'failed') {
+      failTransaction(id as string, 'Deposit failed');
+      toast.error('Deposit failed');
+    }
+  }, [confirmTransaction, failTransaction]);
+
+  // Handle balance messages
+  const handleBalanceMessage = useCallback((message: WebSocketMessage) => {
+    const { address, asset, balance } = message.data as Record<string, unknown>;
+    
+    // Update balance in UI (this would typically update a global state)
+    console.log(`Balance update for ${address}: ${balance} ${asset}`);
+    
+    // Show notification for significant balance changes
+    toast.info(`Balance updated: ${balance} ${asset}`);
+  }, []);
+
+  // Handle error messages
+  const handleErrorMessage = useCallback((message: WebSocketMessage) => {
+    const errorData = message.data;
+    console.error('WebSocket error:', errorData);
+    
+    toast.error(`WebSocket error: ${errorData instanceof Error ? errorData.message : 'Unknown error'}`);
+  }, []);
+
+  // Handle general messages
+  const handleGeneralMessage = useCallback((message: WebSocketMessage) => {
+    setLastMessage(message);
+  }, []);
+
+  // Register event handlers
+  useEffect(() => {
+    websocketClient.on('transaction', handleTransactionMessage);
+    websocketClient.on('deposit', handleDepositMessage);
+    websocketClient.on('balance', handleBalanceMessage);
+    websocketClient.on('error', handleErrorMessage);
+    websocketClient.on('*', handleGeneralMessage);
+
+    return () => {
+      websocketClient.off('transaction', handleTransactionMessage);
+      websocketClient.off('deposit', handleDepositMessage);
+      websocketClient.off('balance', handleBalanceMessage);
+      websocketClient.off('error', handleErrorMessage);
+      websocketClient.off('*', handleGeneralMessage);
+    };
+  }, [handleTransactionMessage, handleDepositMessage, handleBalanceMessage, handleErrorMessage, handleGeneralMessage]);
+
+  // Send message
+  const sendMessage = useCallback((type: string, data?: unknown) => {
+    websocketClient.send({ type: type as "error" | "deposit" | "ping" | "transaction" | "balance" | "pong", data });
+  }, []);
+
+  // Subscribe to address
+  const subscribeToAddress = useCallback((address: string) => {
+    sendMessage('subscribe', { address });
+  }, [sendMessage]);
+
+  // Unsubscribe from address
+  const unsubscribeFromAddress = useCallback((address: string) => {
+    sendMessage('unsubscribe', { address });
+  }, [sendMessage]);
+
+  // Subscribe to transaction
+  const subscribeToTransaction = useCallback((transactionHash: string) => {
+    sendMessage('subscribe_transaction', { transactionHash });
+  }, [sendMessage]);
+
+  // Unsubscribe from transaction
+  const unsubscribeFromTransaction = useCallback((transactionHash: string) => {
+    sendMessage('unsubscribe_transaction', { transactionHash });
+  }, [sendMessage]);
+
+  // Request balance update
+  const requestBalanceUpdate = useCallback((address: string, asset?: string) => {
+    sendMessage('balance_request', { address, asset });
+  }, [sendMessage]);
+
+  // Get connection status
+  const getConnectionStatus = useCallback(() => {
+    return websocketClient.getStatus();
+  }, []);
+
+  return {
+    // State
+    isConnected,
+    isConnecting,
+    reconnectAttempts,
+    lastMessage,
+    
+    // Actions
+    sendMessage,
+    subscribeToAddress,
+    unsubscribeFromAddress,
+    subscribeToTransaction,
+    unsubscribeFromTransaction,
+    requestBalanceUpdate,
+    getConnectionStatus,
+  };
+}
diff --git a/paystell-frontend/src/lib/deposit/__tests__/deposit-utils.test.ts b/paystell-frontend/src/lib/deposit/__tests__/deposit-utils.test.ts
new file mode 100644
index 0000000..47a04f3
--- /dev/null
+++ b/paystell-frontend/src/lib/deposit/__tests__/deposit-utils.test.ts
@@ -0,0 +1,192 @@
+import {
+  generateDepositURI,
+  generateDepositQRData,
+  isValidStellarAddress,
+  formatDepositAmount,
+  isDepositExpired,
+  getDepositStatusColor,
+  getDepositStatusIcon,
+  generateDepositId,
+  calculateDepositExpiration,
+} from '../deposit-utils';
+import { DepositRequest } from '@/lib/types/deposit';
+
+describe('deposit-utils', () => {
+  describe('generateDepositURI', () => {
+    it('should generate a valid Stellar payment URI', () => {
+      const qrData = {
+        address: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        asset: 'XLM',
+        amount: '10.5',
+        memo: 'Test payment',
+        label: 'Test Label',
+        message: 'Test Message',
+      };
+
+      const uri = generateDepositURI(qrData);
+      
+      expect(uri).toContain('web+stellar:pay?');
+      expect(uri).toContain('destination=GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ');
+      expect(uri).toContain('asset_code=XLM');
+      expect(uri).toContain('amount=10.5');
+      expect(uri).toContain('memo=Test%20payment');
+      expect(uri).toContain('label=Test%20Label');
+      expect(uri).toContain('message=Test%20Message');
+    });
+
+    it('should handle native asset correctly', () => {
+      const qrData = {
+        address: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        asset: 'native',
+      };
+
+      const uri = generateDepositURI(qrData);
+      
+      expect(uri).toContain('asset_code=XLM');
+    });
+
+    it('should handle optional fields', () => {
+      const qrData = {
+        address: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        asset: 'USDC',
+      };
+
+      const uri = generateDepositURI(qrData);
+      
+      expect(uri).toContain('asset_code=USDC');
+      expect(uri).not.toContain('amount=');
+      expect(uri).not.toContain('memo=');
+    });
+  });
+
+  describe('generateDepositQRData', () => {
+    it('should generate QR data for a deposit request', () => {
+      const deposit: DepositRequest = {
+        id: 'deposit_123',
+        address: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        amount: '10.5',
+        asset: 'XLM',
+        memo: 'Test memo',
+        status: 'pending',
+        createdAt: '2024-01-01T00:00:00Z',
+        expiresAt: '2024-01-02T00:00:00Z',
+      };
+
+      const qrData = generateDepositQRData(deposit);
+      
+      expect(qrData).toContain('web+stellar:pay?');
+      expect(qrData).toContain('destination=GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ');
+      expect(qrData).toContain('asset_code=XLM');
+      expect(qrData).toContain('amount=10.5');
+      expect(qrData).toContain('memo=Test%20memo');
+    });
+  });
+
+  describe('isValidStellarAddress', () => {
+    it('should validate correct Stellar addresses', () => {
+      const validAddress = 'GBRPYHIL2CVI3VCNJ3UBJLYSDQ4C5SA66PBUZP6N2ZED6OIZ44QYAQZ6';
+      expect(isValidStellarAddress(validAddress)).toBe(true);
+    });
+
+    it('should reject invalid Stellar addresses', () => {
+      const invalidAddresses = [
+        'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXY', // Too short
+        'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ1', // Too long
+        'SABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ', // Wrong prefix
+        'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ0', // Invalid character
+        '',
+        'not-an-address',
+      ];
+
+      invalidAddresses.forEach(address => {
+        expect(isValidStellarAddress(address)).toBe(false);
+      });
+    });
+  });
+
+  describe('formatDepositAmount', () => {
+    it('should format XLM amounts with 7 decimal places', () => {
+      expect(formatDepositAmount('10.123456789', 'XLM')).toBe('10.1234568');
+      expect(formatDepositAmount('10.123456789', 'native')).toBe('10.1234568');
+    });
+
+    it('should format other assets with 2 decimal places', () => {
+      expect(formatDepositAmount('10.123456789', 'USDC')).toBe('10.12');
+      expect(formatDepositAmount('10.123456789', 'USDT')).toBe('10.12');
+    });
+
+    it('should handle invalid amounts', () => {
+      expect(formatDepositAmount('invalid', 'XLM')).toBe('0');
+      expect(formatDepositAmount('', 'XLM')).toBe('0');
+    });
+  });
+
+  describe('isDepositExpired', () => {
+    it('should detect expired deposits', () => {
+      const expiredDeposit: DepositRequest = {
+        id: 'deposit_123',
+        address: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        asset: 'XLM',
+        status: 'pending',
+        createdAt: '2024-01-01T00:00:00Z',
+        expiresAt: '2024-01-01T01:00:00Z', // Expired
+      };
+
+      expect(isDepositExpired(expiredDeposit)).toBe(true);
+    });
+
+    it('should detect non-expired deposits', () => {
+      const futureDate = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
+      const activeDeposit: DepositRequest = {
+        id: 'deposit_123',
+        address: 'GABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        asset: 'XLM',
+        status: 'pending',
+        createdAt: new Date().toISOString(),
+        expiresAt: futureDate,
+      };
+
+      expect(isDepositExpired(activeDeposit)).toBe(false);
+    });
+  });
+
+  describe('getDepositStatusColor', () => {
+    it('should return correct colors for each status', () => {
+      expect(getDepositStatusColor('pending')).toBe('text-yellow-600');
+      expect(getDepositStatusColor('completed')).toBe('text-green-600');
+      expect(getDepositStatusColor('failed')).toBe('text-red-600');
+      expect(getDepositStatusColor('expired')).toBe('text-gray-600');
+    });
+  });
+
+  describe('getDepositStatusIcon', () => {
+    it('should return correct icons for each status', () => {
+      expect(getDepositStatusIcon('pending')).toBe('⏳');
+      expect(getDepositStatusIcon('completed')).toBe('✅');
+      expect(getDepositStatusIcon('failed')).toBe('❌');
+      expect(getDepositStatusIcon('expired')).toBe('⏰');
+    });
+  });
+
+  describe('generateDepositId', () => {
+    it('should generate unique deposit IDs', () => {
+      const id1 = generateDepositId();
+      const id2 = generateDepositId();
+      
+      expect(id1).not.toBe(id2);
+      expect(id1).toMatch(/^deposit_\d+_[a-z0-9]+$/);
+      expect(id2).toMatch(/^deposit_\d+_[a-z0-9]+$/);
+    });
+  });
+
+  describe('calculateDepositExpiration', () => {
+    it('should calculate expiration 24 hours from now', () => {
+      const now = new Date();
+      const expiration = new Date(calculateDepositExpiration());
+      
+      const diffInHours = (expiration.getTime() - now.getTime()) / (1000 * 60 * 60);
+      
+      expect(diffInHours).toBeCloseTo(24, 0);
+    });
+  });
+});
diff --git a/paystell-frontend/src/lib/deposit/deposit-utils.ts b/paystell-frontend/src/lib/deposit/deposit-utils.ts
new file mode 100644
index 0000000..4c12c0f
--- /dev/null
+++ b/paystell-frontend/src/lib/deposit/deposit-utils.ts
@@ -0,0 +1,131 @@
+import { DepositQRData, DepositRequest } from "@/lib/types/deposit";
+
+/**
+ * Generate Stellar payment URI for deposits
+ * Follows SEP-0007 standard for payment requests
+ */
+export function generateDepositURI(data: DepositQRData): string {
+  const params = new URLSearchParams({
+    destination: data.address,
+    asset_code: data.asset === "native" ? "XLM" : data.asset,
+  });
+
+  if (data.amount) {
+    params.append("amount", data.amount);
+  }
+
+  if (data.memo) {
+    params.append("memo", data.memo);
+    params.append("memo_type", "text");
+  }
+
+  if (data.label) {
+    params.append("label", data.label);
+  }
+
+  if (data.message) {
+    params.append("message", data.message);
+  }
+
+  return `web+stellar:pay?${params.toString()}`;
+}
+
+/**
+ * Generate QR code data for deposit requests
+ */
+export function generateDepositQRData(deposit: DepositRequest): string {
+  const qrData: DepositQRData = {
+    address: deposit.address,
+    asset: deposit.asset,
+    memo: deposit.memo,
+    label: `Deposit to PayStell`,
+    message: `Deposit ${deposit.amount || 'any amount'} ${deposit.asset}`,
+  };
+
+  if (deposit.amount) {
+    qrData.amount = deposit.amount;
+  }
+
+  return generateDepositURI(qrData);
+}
+
+/**
+ * Validate Stellar address format
+ */
+export function isValidStellarAddress(address: string): boolean {
+  return /^G[A-Z2-7]{55}$/.test(address);
+}
+
+/**
+ * Format amount for display
+ */
+export function formatDepositAmount(amount: string, asset: string): string {
+  const numAmount = parseFloat(amount);
+  if (isNaN(numAmount)) return "0";
+  
+  // Format with appropriate decimal places
+  if (asset === "XLM" || asset === "native") {
+    return numAmount.toFixed(7);
+  }
+  
+  return numAmount.toFixed(2);
+}
+
+/**
+ * Check if deposit request has expired
+ */
+export function isDepositExpired(deposit: DepositRequest): boolean {
+  return new Date(deposit.expiresAt) < new Date();
+}
+
+/**
+ * Get deposit status color for UI
+ */
+export function getDepositStatusColor(status: DepositRequest['status']): string {
+  switch (status) {
+    case 'pending':
+      return 'text-yellow-600';
+    case 'completed':
+      return 'text-green-600';
+    case 'failed':
+      return 'text-red-600';
+    case 'expired':
+      return 'text-gray-600';
+    default:
+      return 'text-gray-600';
+  }
+}
+
+/**
+ * Get deposit status icon
+ */
+export function getDepositStatusIcon(status: DepositRequest['status']): string {
+  switch (status) {
+    case 'pending':
+      return '⏳';
+    case 'completed':
+      return '✅';
+    case 'failed':
+      return '❌';
+    case 'expired':
+      return '⏰';
+    default:
+      return '❓';
+  }
+}
+
+/**
+ * Generate unique deposit ID
+ */
+export function generateDepositId(): string {
+  return `deposit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+
+/**
+ * Calculate deposit expiration time (24 hours from now)
+ */
+export function calculateDepositExpiration(): string {
+  const expiration = new Date();
+  expiration.setHours(expiration.getHours() + 24);
+  return expiration.toISOString();
+}
diff --git a/paystell-frontend/src/lib/monitoring/stellar-monitor.ts b/paystell-frontend/src/lib/monitoring/stellar-monitor.ts
new file mode 100644
index 0000000..ae42bef
--- /dev/null
+++ b/paystell-frontend/src/lib/monitoring/stellar-monitor.ts
@@ -0,0 +1,281 @@
+"use client";
+
+import { Horizon, Networks } from "@stellar/stellar-sdk";
+import { DepositTransaction, DepositMonitoringConfig } from "@/lib/types/deposit";
+
+// Initialize Horizon server (default to testnet; allow override via env)
+const server = new Horizon.Server(process.env.NEXT_PUBLIC_HORIZON_URL ?? "https://horizon-testnet.stellar.org");
+
+export class StellarMonitor {
+  private monitoringConfigs: Map<string, DepositMonitoringConfig> = new Map();
+  private pollingInterval: NodeJS.Timeout | null = null;
+  private isMonitoring = false;
+  private lastCursors: Map<string, string | null> = new Map();
+  private callbacks: Map<string, (transaction: DepositTransaction) => void> = new Map();
+
+  constructor() {
+    this.startMonitoring();
+  }
+
+  /**
+   * Start monitoring for incoming transactions
+   */
+  private startMonitoring() {
+    if (this.isMonitoring) return;
+    
+    this.isMonitoring = true;
+    this.pollingInterval = setInterval(() => {
+      this.checkForNewTransactions();
+    }, 5000); // Check every 5 seconds
+  }
+
+  /**
+   * Stop monitoring
+   */
+  public stopMonitoring() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = null;
+    }
+    this.isMonitoring = false;
+  }
+
+  /**
+   * Add a monitoring configuration for a specific address
+   */
+  public addMonitoring(config: DepositMonitoringConfig) {
+    const key = `${config.address}_${config.asset}`;
+    this.monitoringConfigs.set(key, config);
+    
+    if (config.callback) {
+      this.callbacks.set(key, config.callback);
+    }
+  }
+
+  /**
+   * Remove monitoring for a specific address
+   */
+  public removeMonitoring(address: string, asset: string) {
+    const key = `${address}_${asset}`;
+    this.monitoringConfigs.delete(key);
+    this.callbacks.delete(key);
+  }
+
+  /**
+   * Check for new transactions
+   */
+  private async checkForNewTransactions() {
+    try {
+      // Get all unique addresses being monitored
+      const addresses = Array.from(this.monitoringConfigs.keys())
+        .map(key => key.split('_')[0])
+        .filter((address, index, self) => self.indexOf(address) === index);
+
+      for (const address of addresses) {
+        await this.checkAddressTransactions(address);
+      }
+    } catch (error) {
+      console.error("Error checking for new transactions:", error);
+    }
+  }
+
+  /**
+   * Check transactions for a specific address
+   */
+  private async checkAddressTransactions(address: string) {
+    try {
+      const builder = server.transactions()
+        .forAccount(address)
+        .order("asc")
+        .limit(10);
+
+      const lastCursor = this.lastCursors.get(address);
+      if (lastCursor) {
+        builder.cursor(lastCursor);
+      }
+
+      const response = await builder.call();
+      const transactions = response.records;
+
+      for (const tx of transactions) {
+        await this.processTransaction(tx as unknown as Record<string, unknown>, address);
+      }
+
+      // Update cursor for next check
+      if (transactions.length > 0) {
+        this.lastCursors.set(address, transactions[transactions.length - 1].paging_token);
+      } else {
+        this.lastCursors.set(address, this.lastCursors.get(address) ?? null);
+      }
+    } catch (error) {
+      console.error(`Error checking transactions for address ${address}:`, error);
+    }
+  }
+
+  /**
+   * Process a transaction and check if it matches monitoring criteria
+   */
+  private async processTransaction(tx: Record<string, unknown>, address: string) {
+    try {
+      const operations = await (tx as { operations(): Promise<{ records: Record<string, unknown>[] }> }).operations();
+      if (operations.records.length === 0) return;
+
+      // Get monitoring configs for this address
+      const configs = Array.from(this.monitoringConfigs.entries())
+        .filter(([key]) => key.startsWith(`${address}_`));
+
+      for (const operation of operations.records) {
+        if (operation.type !== "payment") continue;
+        // Incoming payment only
+        if (operation.to !== address) continue;
+        for (const [key, config] of configs) {
+          const txMemo = (tx as { memo?: string | null }).memo ?? null;
+          if (this.matchesMonitoringCriteria(operation, config, txMemo)) {
+            const depositTransaction = this.createDepositTransaction(tx, operation);
+            await this.handleDepositTransaction(depositTransaction, key);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error processing transaction:", error);
+    }
+  }
+
+  /**
+   * Check if a transaction matches monitoring criteria
+   */
+  private matchesMonitoringCriteria(
+    operation: Record<string, unknown>,
+    config: DepositMonitoringConfig,
+    txMemo?: string | null,
+  ): boolean {
+    // Check asset (normalize native <-> XLM)
+    const normalize = (s: string) => (s.toUpperCase() === "NATIVE" ? "XLM" : s.toUpperCase());
+    const opAsset = operation.asset_type === "native" ? "XLM" : String(operation.asset_code ?? "").toUpperCase();
+    if (normalize(config.asset) !== opAsset) return false;
+
+    // Check minimum amount
+    if (config.minAmount && parseFloat(operation.amount as string) < parseFloat(config.minAmount)) {
+      return false;
+    }
+
+    // Check maximum amount
+    if (config.maxAmount && parseFloat(operation.amount as string) > parseFloat(config.maxAmount)) {
+      return false;
+    }
+
+    // Check memo
+    if (config.memo && txMemo !== config.memo) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Create a DepositTransaction from Stellar transaction data
+   */
+  private createDepositTransaction(tx: Record<string, unknown>, operation: Record<string, unknown>): DepositTransaction {
+    const memo = (tx as { memo?: string | null }).memo ?? undefined;
+    return {
+      id: `deposit_${tx.hash}`,
+      hash: tx.hash as string,
+      amount: operation.amount as string,
+      asset: operation.asset_type === "native" ? "XLM" : operation.asset_code as string,
+      from: operation.from as string,
+      to: operation.to as string,
+      memo,
+      status: "completed",
+      createdAt: tx.created_at as string,
+      confirmedAt: tx.created_at as string,
+      ledger: tx.ledger as number,
+      fee: tx.fee_charged as string,
+    };
+  }
+
+  /**
+   * Handle a deposit transaction
+   */
+  private async handleDepositTransaction(transaction: DepositTransaction, configKey: string) {
+    try {
+      // Deliver callback once per config
+      const deliveredKey = `delivered_${configKey}_${transaction.hash}`;
+      const alreadyDelivered = localStorage.getItem(deliveredKey);
+      if (!alreadyDelivered) {
+        const callback = this.callbacks.get(configKey);
+        if (callback) callback(transaction);
+        localStorage.setItem(deliveredKey, "1");
+      }
+
+      // Persist/store once per tx
+      const processedKey = `processed_${transaction.hash}`;
+      const alreadyProcessed = localStorage.getItem(processedKey);
+      if (!alreadyProcessed) {
+        localStorage.setItem(processedKey, JSON.stringify({ hash: transaction.hash, at: Date.now() }));
+        this.storeTransaction(transaction);
+        console.log("New deposit transaction detected:", transaction);
+      }
+    } catch (error) {
+      console.error("Error handling deposit transaction:", error);
+    }
+  }
+
+  /**
+   * Store transaction in localStorage
+   */
+  private storeTransaction(transaction: DepositTransaction) {
+    try {
+      const stored = localStorage.getItem("paystell_deposit_transactions");
+      const transactions = stored ? JSON.parse(stored) : [];
+      
+      // Check if transaction already exists
+      const exists = transactions.some((t: DepositTransaction) => t.hash === transaction.hash);
+      if (exists) return;
+
+      transactions.unshift(transaction);
+      
+      // Keep only last 100 transactions
+      if (transactions.length > 100) {
+        transactions.splice(100);
+      }
+
+      localStorage.setItem("paystell_deposit_transactions", JSON.stringify(transactions));
+    } catch (error) {
+      console.error("Error storing transaction:", error);
+    }
+  }
+
+  /**
+   * Get transaction history
+   */
+  public getTransactionHistory(): DepositTransaction[] {
+    try {
+      const stored = localStorage.getItem("paystell_deposit_transactions");
+      return stored ? JSON.parse(stored) : [];
+    } catch (error) {
+      console.error("Error getting transaction history:", error);
+      return [];
+    }
+  }
+
+  /**
+   * Clear transaction history
+   */
+  public clearTransactionHistory() {
+    localStorage.removeItem("paystell_deposit_transactions");
+  }
+
+  /**
+   * Get monitoring status
+   */
+  public getMonitoringStatus() {
+    return {
+      isMonitoring: this.isMonitoring,
+      configCount: this.monitoringConfigs.size,
+      addresses: Array.from(this.monitoringConfigs.keys()),
+    };
+  }
+}
+
+// Create a singleton instance
+export const stellarMonitor = new StellarMonitor();
diff --git a/paystell-frontend/src/lib/optimistic/__tests__/optimistic-store.test.ts b/paystell-frontend/src/lib/optimistic/__tests__/optimistic-store.test.ts
new file mode 100644
index 0000000..508ea72
--- /dev/null
+++ b/paystell-frontend/src/lib/optimistic/__tests__/optimistic-store.test.ts
@@ -0,0 +1,254 @@
+import { useOptimisticStore } from '../optimistic-store';
+import { OptimisticTransaction } from '@/lib/types/deposit';
+
+// Mock localStorage
+const localStorageMock = {
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+  removeItem: jest.fn(),
+  clear: jest.fn(),
+};
+Object.defineProperty(window, 'localStorage', {
+  value: localStorageMock,
+});
+
+describe('optimistic-store', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Reset store state
+    useOptimisticStore.setState({
+      queue: {
+        pending: [],
+        processing: [],
+        completed: [],
+        failed: [],
+      },
+      isProcessing: false,
+    });
+  });
+
+  describe('addTransaction', () => {
+    it('should add a transaction to the pending queue', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      useOptimisticStore.getState().addTransaction(transaction);
+
+      const state = useOptimisticStore.getState();
+      expect(state.queue.pending).toHaveLength(1);
+      expect(state.queue.pending[0]).toEqual(transaction);
+    });
+  });
+
+  describe('updateTransaction', () => {
+    it('should update a transaction in the queue', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      // Add transaction
+      useOptimisticStore.getState().addTransaction(transaction);
+
+      // Update transaction
+      useOptimisticStore.getState().updateTransaction('test_123', {
+        status: 'confirmed',
+        transactionHash: 'tx_hash_123',
+      });
+
+      const state = useOptimisticStore.getState();
+      const updatedTransaction = state.queue.pending[0];
+      
+      expect(updatedTransaction.status).toBe('confirmed');
+      expect(updatedTransaction.transactionHash).toBe('tx_hash_123');
+    });
+  });
+
+  describe('removeTransaction', () => {
+    it('should remove a transaction from the queue', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      // Add transaction
+      useOptimisticStore.getState().addTransaction(transaction);
+      expect(useOptimisticStore.getState().queue.pending).toHaveLength(1);
+
+      // Remove transaction
+      useOptimisticStore.getState().removeTransaction('test_123');
+      expect(useOptimisticStore.getState().queue.pending).toHaveLength(0);
+    });
+  });
+
+  describe('moveTransaction', () => {
+    it('should move a transaction between queues', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      // Add transaction
+      useOptimisticStore.getState().addTransaction(transaction);
+      expect(useOptimisticStore.getState().queue.pending).toHaveLength(1);
+      expect(useOptimisticStore.getState().queue.completed).toHaveLength(0);
+
+      // Move transaction
+      useOptimisticStore.getState().moveTransaction('test_123', 'pending', 'completed');
+      
+      const state = useOptimisticStore.getState();
+      expect(state.queue.pending).toHaveLength(0);
+      expect(state.queue.completed).toHaveLength(1);
+      expect(state.queue.completed[0]).toEqual(transaction);
+    });
+  });
+
+  describe('getTransaction', () => {
+    it('should get a transaction by ID', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      // Add transaction
+      useOptimisticStore.getState().addTransaction(transaction);
+
+      // Get transaction
+      const foundTransaction = useOptimisticStore.getState().getTransaction('test_123');
+      expect(foundTransaction).toEqual(transaction);
+    });
+
+    it('should return undefined for non-existent transaction', () => {
+      const foundTransaction = useOptimisticStore.getState().getTransaction('non_existent');
+      expect(foundTransaction).toBeUndefined();
+    });
+  });
+
+  describe('getTransactionsByStatus', () => {
+    it('should get transactions by status', () => {
+      const transaction1: OptimisticTransaction = {
+        id: 'test_1',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      const transaction2: OptimisticTransaction = {
+        id: 'test_2',
+        type: 'withdraw',
+        amount: '5.0',
+        asset: 'USDC',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      const transaction3: OptimisticTransaction = {
+        id: 'test_3',
+        type: 'deposit',
+        amount: '20.0',
+        asset: 'XLM',
+        status: 'confirmed',
+        timestamp: Date.now(),
+      };
+
+      // Add transactions
+      useOptimisticStore.getState().addTransaction(transaction1);
+      useOptimisticStore.getState().addTransaction(transaction2);
+      useOptimisticStore.getState().addTransaction(transaction3);
+
+      // Get pending transactions
+      const pendingTransactions = useOptimisticStore.getState().getTransactionsByStatus('pending');
+      expect(pendingTransactions).toHaveLength(2);
+      expect(pendingTransactions).toContainEqual(transaction1);
+      expect(pendingTransactions).toContainEqual(transaction2);
+
+      // Get confirmed transactions
+      const confirmedTransactions = useOptimisticStore.getState().getTransactionsByStatus('confirmed');
+      expect(confirmedTransactions).toHaveLength(1);
+      expect(confirmedTransactions).toContainEqual(transaction3);
+    });
+  });
+
+  describe('clearCompleted', () => {
+    it('should clear completed transactions', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'confirmed',
+        timestamp: Date.now(),
+      };
+
+      // Add transaction to completed queue
+      useOptimisticStore.setState({
+        queue: {
+          pending: [],
+          processing: [],
+          completed: [transaction],
+          failed: [],
+        },
+      });
+
+      expect(useOptimisticStore.getState().queue.completed).toHaveLength(1);
+
+      // Clear completed
+      useOptimisticStore.getState().clearCompleted();
+      expect(useOptimisticStore.getState().queue.completed).toHaveLength(0);
+    });
+  });
+
+  describe('clearFailed', () => {
+    it('should clear failed transactions', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'failed',
+        timestamp: Date.now(),
+        error: 'Test error',
+      };
+
+      // Add transaction to failed queue
+      useOptimisticStore.setState({
+        queue: {
+          pending: [],
+          processing: [],
+          completed: [],
+          failed: [transaction],
+        },
+      });
+
+      expect(useOptimisticStore.getState().queue.failed).toHaveLength(1);
+
+      // Clear failed
+      useOptimisticStore.getState().clearFailed();
+      expect(useOptimisticStore.getState().queue.failed).toHaveLength(0);
+    });
+  });
+});
diff --git a/paystell-frontend/src/lib/optimistic/optimistic-store.ts b/paystell-frontend/src/lib/optimistic/optimistic-store.ts
new file mode 100644
index 0000000..0271017
--- /dev/null
+++ b/paystell-frontend/src/lib/optimistic/optimistic-store.ts
@@ -0,0 +1,187 @@
+"use client";
+
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import { OptimisticTransaction, TransactionQueueSummary } from "@/lib/types/deposit";
+
+interface OptimisticState {
+  queue: TransactionQueueSummary;
+  isProcessing: boolean;
+  
+  // Actions
+  addTransaction: (transaction: OptimisticTransaction) => void;
+  updateTransaction: (id: string, updates: Partial<OptimisticTransaction>) => void;
+  removeTransaction: (id: string) => void;
+  moveTransaction: (id: string, from: keyof TransactionQueueSummary, to: keyof TransactionQueueSummary) => void;
+  processQueue: () => Promise<void>;
+  clearCompleted: () => void;
+  clearFailed: () => void;
+  getTransaction: (id: string) => OptimisticTransaction | undefined;
+  getTransactionsByStatus: (status: OptimisticTransaction['status']) => OptimisticTransaction[];
+}
+
+export const useOptimisticStore = create<OptimisticState>()(
+  persist(
+    (set, get) => ({
+      queue: {
+        pending: [],
+        processing: [],
+        completed: [],
+        failed: [],
+      },
+      isProcessing: false,
+
+      addTransaction: (transaction: OptimisticTransaction) => {
+        set((state) => ({
+          queue: {
+            ...state.queue,
+            pending: [...state.queue.pending, transaction],
+          },
+        }));
+      },
+
+      updateTransaction: (id: string, updates: Partial<OptimisticTransaction>) => {
+        set((state) => {
+          const updateInArray = (arr: OptimisticTransaction[]) =>
+            arr.map((tx) => (tx.id === id ? { ...tx, ...updates } : tx));
+
+          return {
+            queue: {
+              pending: updateInArray(state.queue.pending),
+              processing: updateInArray(state.queue.processing),
+              completed: updateInArray(state.queue.completed),
+              failed: updateInArray(state.queue.failed),
+            },
+          };
+        });
+      },
+
+      removeTransaction: (id: string) => {
+        set((state) => {
+          const removeFromArray = (arr: OptimisticTransaction[]) =>
+            arr.filter((tx) => tx.id !== id);
+
+          return {
+            queue: {
+              pending: removeFromArray(state.queue.pending),
+              processing: removeFromArray(state.queue.processing),
+              completed: removeFromArray(state.queue.completed),
+              failed: removeFromArray(state.queue.failed),
+            },
+          };
+        });
+      },
+
+      moveTransaction: (id: string, from: keyof TransactionQueueSummary, to: keyof TransactionQueueSummary) => {
+        set((state) => {
+          const transaction = state.queue[from].find((tx) => tx.id === id);
+          if (!transaction) return state;
+
+          const newFrom = state.queue[from].filter((tx) => tx.id !== id);
+          const newTo = [...state.queue[to], transaction];
+
+          return {
+            queue: {
+              ...state.queue,
+              [from]: newFrom,
+              [to]: newTo,
+            },
+          };
+        });
+      },
+
+      processQueue: async () => {
+        const state = get();
+        if (state.isProcessing) return;
+
+        set({ isProcessing: true });
+
+        try {
+          const { queue } = state;
+          const pendingTransactions = [...queue.pending];
+
+          for (const transaction of pendingTransactions) {
+            // Move to processing
+            get().moveTransaction(transaction.id, "pending", "processing");
+
+            try {
+              // Simulate processing delay
+              await new Promise((resolve) => setTimeout(resolve, 1000));
+
+              // Simulate success/failure (90% success rate)
+              const isSuccess = Math.random() > 0.1;
+
+              if (isSuccess) {
+                get().updateTransaction(transaction.id, {
+                  status: "completed",
+                  transactionHash: `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                });
+                get().moveTransaction(transaction.id, "processing", "completed");
+              } else {
+                get().updateTransaction(transaction.id, {
+                  status: "failed",
+                  error: "Transaction failed to confirm",
+                });
+                get().moveTransaction(transaction.id, "processing", "failed");
+              }
+            } catch (error) {
+              get().updateTransaction(transaction.id, {
+                status: "failed",
+                error: error instanceof Error ? error.message : "Unknown error",
+              });
+              get().moveTransaction(transaction.id, "processing", "failed");
+            }
+          }
+        } finally {
+          set({ isProcessing: false });
+        }
+      },
+
+      clearCompleted: () => {
+        set((state) => ({
+          queue: {
+            ...state.queue,
+            completed: [],
+          },
+        }));
+      },
+
+      clearFailed: () => {
+        set((state) => ({
+          queue: {
+            ...state.queue,
+            failed: [],
+          },
+        }));
+      },
+
+      getTransaction: (id: string) => {
+        const state = get();
+        const allTransactions = [
+          ...state.queue.pending,
+          ...state.queue.processing,
+          ...state.queue.completed,
+          ...state.queue.failed,
+        ];
+        return allTransactions.find((tx) => tx.id === id);
+      },
+
+      getTransactionsByStatus: (status: OptimisticTransaction['status']) => {
+        const state = get();
+        const allTransactions = [
+          ...state.queue.pending,
+          ...state.queue.processing,
+          ...state.queue.completed,
+          ...state.queue.failed,
+        ];
+        return allTransactions.filter((tx) => tx.status === status);
+      },
+    }),
+    {
+      name: "optimistic-transactions",
+      partialize: (state) => ({
+        queue: state.queue,
+      }),
+    }
+  )
+);
diff --git a/paystell-frontend/src/lib/queue/__tests__/transaction-queue.test.ts b/paystell-frontend/src/lib/queue/__tests__/transaction-queue.test.ts
new file mode 100644
index 0000000..f7c6d3c
--- /dev/null
+++ b/paystell-frontend/src/lib/queue/__tests__/transaction-queue.test.ts
@@ -0,0 +1,356 @@
+import { TransactionQueue, QueueItem } from '../transaction-queue';
+import { OptimisticTransaction } from '@/lib/types/deposit';
+
+describe('TransactionQueue', () => {
+  let queue: TransactionQueue;
+
+  beforeEach(() => {
+    queue = new TransactionQueue({
+      maxRetries: 3,
+      retryDelay: 1000,
+      maxQueueSize: 10,
+      processingTimeout: 5000,
+    });
+  });
+
+  describe('add', () => {
+    it('should add a transaction to the queue', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      const id = queue.add(transaction);
+      expect(id).toBe('test_123');
+      
+      const queueItems = queue.getQueue();
+      expect(queueItems).toHaveLength(1);
+      expect(queueItems[0].transaction).toEqual(transaction);
+    });
+
+    it('should throw error when queue is full', () => {
+      // Fill the queue
+      for (let i = 0; i < 10; i++) {
+        const transaction: OptimisticTransaction = {
+          id: `test_${i}`,
+          type: 'deposit',
+          amount: '10.5',
+          asset: 'XLM',
+          status: 'pending',
+          timestamp: Date.now(),
+        };
+        queue.add(transaction);
+      }
+
+      // Try to add one more
+      const transaction: OptimisticTransaction = {
+        id: 'test_overflow',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      expect(() => queue.add(transaction)).toThrow('Queue is full');
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove a transaction from the queue', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      expect(queue.getQueue()).toHaveLength(1);
+
+      const removed = queue.remove('test_123');
+      expect(removed).toBe(true);
+      expect(queue.getQueue()).toHaveLength(0);
+    });
+
+    it('should return false for non-existent transaction', () => {
+      const removed = queue.remove('non_existent');
+      expect(removed).toBe(false);
+    });
+  });
+
+  describe('getNext', () => {
+    it('should return the next item to process', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      const nextItem = queue.getNext();
+      
+      expect(nextItem).toBeDefined();
+      expect(nextItem?.transaction).toEqual(transaction);
+    });
+
+    it('should return null when queue is empty', () => {
+      const nextItem = queue.getNext();
+      expect(nextItem).toBeNull();
+    });
+
+    it('should not return items that are being processed', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      queue.markProcessing('test_123');
+      
+      const nextItem = queue.getNext();
+      expect(nextItem).toBeNull();
+    });
+  });
+
+  describe('markProcessing', () => {
+    it('should mark an item as processing', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      const marked = queue.markProcessing('test_123');
+      
+      expect(marked).toBe(true);
+      expect(queue.getStatus().processing).toBe(1);
+    });
+
+    it('should return false for non-existent item', () => {
+      const marked = queue.markProcessing('non_existent');
+      expect(marked).toBe(false);
+    });
+  });
+
+  describe('markCompleted', () => {
+    it('should mark an item as completed', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      queue.markProcessing('test_123');
+      
+      const completed = queue.markCompleted('test_123', 'tx_hash_123');
+      
+      expect(completed).toBe(true);
+      expect(queue.getStatus().completed).toBe(1);
+      expect(queue.getStatus().processing).toBe(0);
+      
+      const completedItems = queue.getCompleted();
+      expect(completedItems[0].transaction.transactionHash).toBe('tx_hash_123');
+      expect(completedItems[0].transaction.status).toBe('confirmed');
+    });
+  });
+
+  describe('markFailed', () => {
+    it('should retry failed item if under max retries', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      queue.markProcessing('test_123');
+      
+      const failed = queue.markFailed('test_123', 'Test error');
+      
+      expect(failed).toBe(true);
+      expect(queue.getStatus().failed).toBe(0);
+      expect(queue.getStatus().processing).toBe(0);
+      
+      const queueItems = queue.getQueue();
+      expect(queueItems[0].retries).toBe(1);
+      expect(queueItems[0].transaction.error).toBe('Test error');
+    });
+
+    it('should move to failed queue after max retries', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      
+      // Fail 3 times (max retries)
+      for (let i = 0; i < 3; i++) {
+        queue.markProcessing('test_123');
+        queue.markFailed('test_123', 'Test error');
+      }
+      
+      expect(queue.getStatus().failed).toBe(1);
+      expect(queue.getStatus().pending).toBe(0);
+    });
+  });
+
+  describe('getStatus', () => {
+    it('should return correct queue status', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      queue.markProcessing('test_123');
+      queue.markCompleted('test_123', 'tx_hash_123');
+      
+      const status = queue.getStatus();
+      expect(status.pending).toBe(0);
+      expect(status.processing).toBe(0);
+      expect(status.completed).toBe(1);
+      expect(status.failed).toBe(0);
+      expect(status.total).toBe(1);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all queues', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      queue.markProcessing('test_123');
+      queue.markCompleted('test_123', 'tx_hash_123');
+      
+      queue.clear();
+      
+      const status = queue.getStatus();
+      expect(status.total).toBe(0);
+    });
+  });
+
+  describe('retry', () => {
+    it('should retry a failed item', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'failed',
+        timestamp: Date.now(),
+        error: 'Test error',
+      };
+
+      // Add to failed queue
+      queue.add(transaction);
+      queue.markProcessing('test_123');
+      queue.markFailed('test_123', 'Test error');
+      queue.markFailed('test_123', 'Test error');
+      queue.markFailed('test_123', 'Test error');
+      
+      expect(queue.getStatus().failed).toBe(1);
+      
+      const retried = queue.retry('test_123');
+      expect(retried).toBe(true);
+      expect(queue.getStatus().failed).toBe(0);
+      expect(queue.getStatus().pending).toBe(1);
+      
+      const queueItems = queue.getQueue();
+      expect(queueItems[0].retries).toBe(0);
+      expect(queueItems[0].transaction.status).toBe('pending');
+      expect(queueItems[0].transaction.error).toBeUndefined();
+    });
+  });
+
+  describe('getItem', () => {
+    it('should get an item by ID', () => {
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      const item = queue.getItem('test_123');
+      
+      expect(item).toBeDefined();
+      expect(item?.transaction).toEqual(transaction);
+    });
+
+    it('should return null for non-existent item', () => {
+      const item = queue.getItem('non_existent');
+      expect(item).toBeNull();
+    });
+  });
+
+  describe('event handling', () => {
+    it('should emit events when items are added', () => {
+      const eventHandler = jest.fn();
+      queue.on('item_added', eventHandler);
+
+      const transaction: OptimisticTransaction = {
+        id: 'test_123',
+        type: 'deposit',
+        amount: '10.5',
+        asset: 'XLM',
+        status: 'pending',
+        timestamp: Date.now(),
+      };
+
+      queue.add(transaction);
+      
+      expect(eventHandler).toHaveBeenCalledWith({
+        type: 'item_added',
+        item: expect.objectContaining({
+          id: 'test_123',
+          transaction,
+        }),
+        timestamp: expect.any(Number),
+      });
+    });
+  });
+});
diff --git a/paystell-frontend/src/lib/queue/transaction-queue.ts b/paystell-frontend/src/lib/queue/transaction-queue.ts
new file mode 100644
index 0000000..8cfd0b2
--- /dev/null
+++ b/paystell-frontend/src/lib/queue/transaction-queue.ts
@@ -0,0 +1,396 @@
+"use client";
+
+import { OptimisticTransaction } from "@/lib/types/deposit";
+
+export interface QueueConfig {
+  maxRetries: number;
+  retryDelay: number;
+  maxQueueSize: number;
+  processingTimeout: number;
+}
+
+export interface QueueItem {
+  id: string;
+  transaction: OptimisticTransaction;
+  retries: number;
+  createdAt: number;
+  lastAttempt?: number;
+  nextRetry?: number;
+}
+
+export interface QueueStatus {
+  pending: number;
+  processing: number;
+  completed: number;
+  failed: number;
+  total: number;
+}
+
+export type QueueEventType = 'item_added' | 'item_processing' | 'item_completed' | 'item_failed' | 'item_retry' | 'queue_cleared';
+
+export interface QueueEvent {
+  type: QueueEventType;
+  item: QueueItem | null;
+  timestamp: number;
+}
+
+export type QueueEventHandler = (event: QueueEvent) => void;
+
+export class TransactionQueue {
+  private queue: QueueItem[] = [];
+  private processing: Set<string> = new Set();
+  private completed: QueueItem[] = [];
+  private failed: QueueItem[] = [];
+  private config: QueueConfig;
+  private eventHandlers: Map<QueueEventType, QueueEventHandler[]> = new Map();
+  private processingInterval: NodeJS.Timeout | null = null;
+  private isProcessing = false;
+
+  constructor(config: Partial<QueueConfig> = {}) {
+    this.config = {
+      maxRetries: 3,
+      retryDelay: 5000,
+      maxQueueSize: 100,
+      processingTimeout: 30000,
+      ...config,
+    };
+  }
+
+  /**
+   * Add a transaction to the queue
+   */
+  public add(transaction: OptimisticTransaction): string {
+    // Check queue size limit
+    if (this.queue.length >= this.config.maxQueueSize) {
+      throw new Error('Queue is full');
+    }
+
+    const item: QueueItem = {
+      id: transaction.id,
+      transaction,
+      retries: 0,
+      createdAt: Date.now(),
+    };
+
+    this.queue.push(item);
+    this.emitEvent('item_added', item);
+    
+    return item.id;
+  }
+
+  /**
+   * Remove an item from the queue
+   */
+  public remove(id: string): boolean {
+    const index = this.queue.findIndex(item => item.id === id);
+    if (index === -1) return false;
+
+    const item = this.queue[index];
+    this.queue.splice(index, 1);
+    this.processing.delete(id);
+    
+    return true;
+  }
+
+  /**
+   * Get the next item to process
+   */
+  public getNext(): QueueItem | null {
+    // Find the next item that's not being processed and is ready for retry
+    const now = Date.now();
+    const item = this.queue.find(item => 
+      !this.processing.has(item.id) && 
+      (!item.nextRetry || item.nextRetry <= now)
+    );
+
+    return item || null;
+  }
+
+  /**
+   * Mark an item as processing
+   */
+  public markProcessing(id: string): boolean {
+    const item = this.queue.find(item => item.id === id);
+    if (!item) return false;
+
+    this.processing.add(id);
+    item.lastAttempt = Date.now();
+    this.emitEvent('item_processing', item);
+    
+    return true;
+  }
+
+  /**
+   * Mark an item as completed
+   */
+  public markCompleted(id: string, transactionHash?: string): boolean {
+    const item = this.queue.find(item => item.id === id);
+    if (!item) return false;
+
+    // Update transaction with hash
+    if (transactionHash) {
+      item.transaction.transactionHash = transactionHash;
+      item.transaction.status = 'completed';
+    }
+
+    // Move to completed
+    this.queue = this.queue.filter(item => item.id !== id);
+    this.processing.delete(id);
+    this.completed.push(item);
+    
+    this.emitEvent('item_completed', item);
+    return true;
+  }
+
+  /**
+   * Mark an item as failed
+   */
+  public markFailed(id: string, error: string): boolean {
+    const item = this.queue.find(item => item.id === id);
+    if (!item) return false;
+
+    item.transaction.status = 'failed';
+    item.transaction.error = error;
+    item.retries++;
+
+    // Check if we should retry
+    if (item.retries < this.config.maxRetries) {
+      item.nextRetry = Date.now() + this.config.retryDelay;
+      this.processing.delete(id);
+      this.emitEvent('item_retry', item);
+    } else {
+      // Move to failed
+      this.queue = this.queue.filter(queueItem => queueItem.id !== id);
+      this.processing.delete(id);
+      this.failed.push(item);
+      this.emitEvent('item_failed', item);
+    }
+    
+    return true;
+  }
+
+  /**
+   * Start processing the queue
+   */
+  public startProcessing(): void {
+    if (this.isProcessing) return;
+    
+    this.isProcessing = true;
+    this.processingInterval = setInterval(() => {
+      this.processNext();
+    }, 1000); // Check every second
+  }
+
+  /**
+   * Stop processing the queue
+   */
+  public stopProcessing(): void {
+    this.isProcessing = false;
+    if (this.processingInterval) {
+      clearInterval(this.processingInterval);
+      this.processingInterval = null;
+    }
+  }
+
+  /**
+   * Process the next item in the queue
+   */
+  private async processNext(): Promise<void> {
+    const item = this.getNext();
+    if (!item) return;
+
+    try {
+      this.markProcessing(item.id);
+      
+      // Simulate processing
+      await this.processItem(item);
+      
+      // Mark as completed
+      this.markCompleted(item.id, `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      this.markFailed(item.id, errorMessage);
+    }
+  }
+
+  /**
+   * Process a single item
+   */
+  private async processItem(item: QueueItem): Promise<void> {
+    // Simulate processing delay
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // Simulate success/failure (90% success rate)
+    const isSuccess = Math.random() > 0.1;
+    
+    if (!isSuccess) {
+      throw new Error('Simulated processing failure');
+    }
+  }
+
+  /**
+   * Get queue status
+   */
+  public getStatus(): QueueStatus {
+    const pendingItems = this.queue.filter(item => !this.processing.has(item.id));
+    const processingCount = this.processing.size;
+    const completedCount = this.completed.length;
+    const failedCount = this.failed.length;
+
+    return {
+      pending: pendingItems.length,
+      processing: processingCount,
+      completed: completedCount,
+      failed: failedCount,
+      total: pendingItems.length + processingCount + completedCount + failedCount,
+    };
+  }
+
+  /**
+   * Get all items in the queue
+   */
+  public getQueue(): QueueItem[] {
+    return [...this.queue];
+  }
+
+  /**
+   * Get all completed items
+   */
+  public getCompleted(): QueueItem[] {
+    return [...this.completed];
+  }
+
+  /**
+   * Get all failed items
+   */
+  public getFailed(): QueueItem[] {
+    return [...this.failed];
+  }
+
+  /**
+   * Get all items
+   */
+  public getAllItems(): QueueItem[] {
+    return [
+      ...this.queue,
+      ...this.completed,
+      ...this.failed,
+    ];
+  }
+
+  /**
+   * Clear the queue
+   */
+  public clear(): void {
+    this.queue = [];
+    this.processing.clear();
+    this.completed = [];
+    this.failed = [];
+    this.emitEvent('queue_cleared', null);
+  }
+
+  /**
+   * Clear completed items
+   */
+  public clearCompleted(): void {
+    this.completed = [];
+  }
+
+  /**
+   * Clear failed items
+   */
+  public clearFailed(): void {
+    this.failed = [];
+  }
+
+  /**
+   * Retry a failed item
+   */
+  public retry(id: string): boolean {
+    const item = this.failed.find(item => item.id === id);
+    if (!item) return false;
+
+    // Reset item
+    item.retries = 0;
+    item.nextRetry = undefined;
+    item.lastAttempt = undefined;
+    item.transaction.status = 'pending';
+    item.transaction.error = undefined;
+
+    // Move back to queue
+    this.failed = this.failed.filter(failedItem => failedItem.id !== id);
+    this.queue.push(item);
+
+    return true;
+  }
+
+  /**
+   * Get item by ID
+   */
+  public getItem(id: string): QueueItem | null {
+    const allItems = this.getAllItems();
+    return allItems.find(item => item.id === id) || null;
+  }
+
+  /**
+   * Subscribe to queue events
+   */
+  public on(eventType: QueueEventType, handler: QueueEventHandler): void {
+    if (!this.eventHandlers.has(eventType)) {
+      this.eventHandlers.set(eventType, []);
+    }
+    this.eventHandlers.get(eventType)!.push(handler);
+  }
+
+  /**
+   * Unsubscribe from queue events
+   */
+  public off(eventType: QueueEventType, handler: QueueEventHandler): void {
+    const handlers = this.eventHandlers.get(eventType);
+    if (handlers) {
+      const index = handlers.indexOf(handler);
+      if (index > -1) {
+        handlers.splice(index, 1);
+      }
+    }
+  }
+
+  /**
+   * Emit a queue event
+   */
+  private emitEvent(eventType: QueueEventType, item: QueueItem | null): void {
+    const event: QueueEvent = {
+      type: eventType,
+      item,
+      timestamp: Date.now(),
+    };
+
+    const handlers = this.eventHandlers.get(eventType);
+    if (handlers) {
+      handlers.forEach(handler => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error('Error in queue event handler:', error);
+        }
+      });
+    }
+  }
+
+  /**
+   * Update queue configuration
+   */
+  public updateConfig(newConfig: Partial<QueueConfig>): void {
+    this.config = { ...this.config, ...newConfig };
+  }
+
+  /**
+   * Get queue configuration
+   */
+  public getConfig(): QueueConfig {
+    return { ...this.config };
+  }
+}
+
+// Create a singleton instance
+export const transactionQueue = new TransactionQueue();
diff --git a/paystell-frontend/src/lib/types/deposit.ts b/paystell-frontend/src/lib/types/deposit.ts
new file mode 100644
index 0000000..4b306c0
--- /dev/null
+++ b/paystell-frontend/src/lib/types/deposit.ts
@@ -0,0 +1,64 @@
+export interface DepositRequest {
+  id: string;
+  ownerId: string;
+  address: string;
+  amount?: string;
+  asset: string;
+  memo?: string;
+  status: 'pending' | 'completed' | 'failed' | 'expired';
+  createdAt: string;
+  expiresAt: string;
+  confirmedAt?: string;
+  transactionHash?: string;
+}
+
+export interface DepositQRData {
+  address: string;
+  amount?: string;
+  asset: string;
+  memo?: string;
+  label?: string;
+  message?: string;
+}
+
+export interface DepositTransaction {
+  id: string;
+  hash: string;
+  amount: string;
+  asset: string;
+  from: string;
+  to: string;
+  memo?: string;
+  status: 'pending' | 'completed' | 'failed';
+  createdAt: string;
+  confirmedAt?: string;
+  ledger?: number;
+  fee: string;
+}
+
+export interface OptimisticTransaction {
+  id: string;
+  type: 'deposit' | 'withdraw';
+  amount: string;
+  asset: string;
+  status: 'pending' | 'completed' | 'failed';
+  timestamp: number;
+  transactionHash?: string;
+  error?: string;
+}
+
+export interface TransactionQueueSummary {
+  pending: OptimisticTransaction[];
+  processing: OptimisticTransaction[];
+  completed: OptimisticTransaction[];
+  failed: OptimisticTransaction[];
+}
+
+export interface DepositMonitoringConfig {
+  address: string;
+  asset: string;
+  minAmount?: string;
+  maxAmount?: string;
+  memo?: string;
+  callback?: (transaction: DepositTransaction) => void;
+}
diff --git a/paystell-frontend/src/lib/websocket/websocket-client.ts b/paystell-frontend/src/lib/websocket/websocket-client.ts
new file mode 100644
index 0000000..3544a8c
--- /dev/null
+++ b/paystell-frontend/src/lib/websocket/websocket-client.ts
@@ -0,0 +1,285 @@
+"use client";
+
+import { DepositTransaction, OptimisticTransaction } from "@/lib/types/deposit";
+
+export interface WebSocketMessage {
+  type: 'transaction' | 'deposit' | 'balance' | 'error' | 'ping' | 'pong';
+  data?: unknown;
+  timestamp: number;
+}
+
+export interface TransactionMessage extends WebSocketMessage {
+  type: 'transaction';
+  data: DepositTransaction;
+}
+
+export interface DepositMessage extends WebSocketMessage {
+  type: 'deposit';
+  data: {
+    id: string;
+    status: string;
+    transactionHash?: string;
+  };
+}
+
+export interface BalanceMessage extends WebSocketMessage {
+  type: 'balance';
+  data: {
+    address: string;
+    asset: string;
+    balance: string;
+  };
+}
+
+export interface ErrorMessage extends WebSocketMessage {
+  type: 'error';
+  data: {
+    message: string;
+    code?: string;
+  };
+}
+
+export type WebSocketEventCallback = (message: WebSocketMessage) => void;
+
+export class WebSocketClient {
+  private ws: WebSocket | null = null;
+  private url: string;
+  private reconnectAttempts = 0;
+  private maxReconnectAttempts = 5;
+  private reconnectDelay = 1000;
+  private isConnecting = false;
+  private isConnected = false;
+  private eventCallbacks: Map<string, WebSocketEventCallback[]> = new Map();
+  private pingInterval: NodeJS.Timeout | null = null;
+  private reconnectTimeout: NodeJS.Timeout | null = null;
+  private shouldReconnect = true;
+
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  /**
+   * Connect to WebSocket server
+   */
+  public connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (this.isConnecting || this.isConnected) {
+        resolve();
+        return;
+      }
+
+      this.isConnecting = true;
+      this.shouldReconnect = true;
+
+      try {
+        this.ws = new WebSocket(this.url);
+
+        this.ws.onopen = () => {
+          console.log('WebSocket connected');
+          this.isConnected = true;
+          this.isConnecting = false;
+          this.reconnectAttempts = 0;
+          this.startPing();
+          resolve();
+        };
+
+        this.ws.onmessage = (event) => {
+          try {
+            const message: WebSocketMessage = JSON.parse(event.data);
+            this.handleMessage(message);
+          } catch (error) {
+            console.error('Error parsing WebSocket message:', error);
+          }
+        };
+
+        this.ws.onclose = (event) => {
+          console.log('WebSocket disconnected:', event.code, event.reason);
+          this.isConnected = false;
+          this.isConnecting = false;
+          this.stopPing();
+          if (this.shouldReconnect) {
+            this.handleReconnect();
+          }
+        };
+
+        this.ws.onerror = (error) => {
+          console.error('WebSocket error:', error);
+          this.isConnecting = false;
+          reject(error);
+        };
+      } catch (error) {
+        this.isConnecting = false;
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Disconnect from WebSocket server
+   */
+  public disconnect(): void {
+    this.shouldReconnect = false;
+    this.stopPing();
+    this.clearReconnectTimeout();
+    
+    if (this.ws) {
+      this.ws.close(1000, 'Client disconnect');
+      this.ws = null;
+    }
+    
+    this.isConnected = false;
+    this.isConnecting = false;
+  }
+
+  /**
+   * Send a message to the server
+   */
+  public send(message: Partial<WebSocketMessage>): void {
+    if (!this.isConnected || !this.ws) {
+      console.warn('WebSocket not connected, cannot send message');
+      return;
+    }
+
+    const fullMessage: WebSocketMessage = {
+      type: 'ping',
+      timestamp: Date.now(),
+      ...message,
+    };
+
+    try {
+      this.ws.send(JSON.stringify(fullMessage));
+    } catch (error) {
+      console.error('Error sending WebSocket message:', error);
+    }
+  }
+
+  /**
+   * Subscribe to a specific message type
+   */
+  public on(type: string, callback: WebSocketEventCallback): void {
+    if (!this.eventCallbacks.has(type)) {
+      this.eventCallbacks.set(type, []);
+    }
+    this.eventCallbacks.get(type)!.push(callback);
+  }
+
+  /**
+   * Unsubscribe from a specific message type
+   */
+  public off(type: string, callback: WebSocketEventCallback): void {
+    const callbacks = this.eventCallbacks.get(type);
+    if (callbacks) {
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+      }
+    }
+  }
+
+  /**
+   * Get connection status
+   */
+  public getStatus(): {
+    isConnected: boolean;
+    isConnecting: boolean;
+    reconnectAttempts: number;
+  } {
+    return {
+      isConnected: this.isConnected,
+      isConnecting: this.isConnecting,
+      reconnectAttempts: this.reconnectAttempts,
+    };
+  }
+
+  /**
+   * Handle incoming messages
+   */
+  private handleMessage(message: WebSocketMessage): void {
+    // Handle pong messages
+    if (message.type === 'pong') {
+      return;
+    }
+
+    // Call registered callbacks
+    const callbacks = this.eventCallbacks.get(message.type);
+    if (callbacks) {
+      callbacks.forEach(callback => {
+        try {
+          callback(message);
+        } catch (error) {
+          console.error('Error in WebSocket callback:', error);
+        }
+      });
+    }
+
+    // Call general callbacks
+    const generalCallbacks = this.eventCallbacks.get('*');
+    if (generalCallbacks) {
+      generalCallbacks.forEach(callback => {
+        try {
+          callback(message);
+        } catch (error) {
+          console.error('Error in WebSocket general callback:', error);
+        }
+      });
+    }
+  }
+
+  /**
+   * Handle reconnection logic
+   */
+  private handleReconnect(): void {
+    if (!this.shouldReconnect) {
+      return;
+    }
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error('Max reconnection attempts reached');
+      return;
+    }
+
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+
+    console.log(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+
+    this.reconnectTimeout = setTimeout(() => {
+      this.connect().catch(error => {
+        console.error('Reconnection failed:', error);
+      });
+    }, delay);
+  }
+
+  /**
+   * Start ping interval
+   */
+  private startPing(): void {
+    this.pingInterval = setInterval(() => {
+      this.send({ type: 'ping' });
+    }, 30000); // Ping every 30 seconds
+  }
+
+  /**
+   * Stop ping interval
+   */
+  private stopPing(): void {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+
+  /**
+   * Clear reconnect timeout
+   */
+  private clearReconnectTimeout(): void {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+}
+
+// Create a singleton instance
+export const websocketClient = new WebSocketClient(
+  process.env.NEXT_PUBLIC_WEBSOCKET_URL || 'ws://localhost:3001'
+);
diff --git a/paystell-frontend/src/providers/MockAuthProvider.tsx b/paystell-frontend/src/providers/MockAuthProvider.tsx
new file mode 100644
index 0000000..bb51222
--- /dev/null
+++ b/paystell-frontend/src/providers/MockAuthProvider.tsx
@@ -0,0 +1,151 @@
+"use client";
+
+import React, { createContext, useContext, useState, useEffect } from "react";
+import { Permission } from "@/lib/types/user";
+
+interface MockUser {
+  id: number;
+  name: string;
+  email: string;
+  role: string;
+  isEmailVerified: boolean;
+  isWalletVerified: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+interface MockAuthContextType {
+  user: MockUser | null;
+  token: string | null;
+  isAuthenticated: boolean;
+  login: (email: string, password: string) => Promise<void>;
+  register: (
+    name: string,
+    email: string,
+    password: string,
+    role: string
+  ) => Promise<void>;
+  logout: () => Promise<void>;
+  loading: boolean;
+  isLoading: boolean;
+  hasPermission: (permission: Permission) => boolean;
+}
+
+const MockAuthContext = createContext<MockAuthContextType | undefined>(undefined);
+
+export const MockAuthProvider: React.FC<{ children: React.ReactNode }> = ({
+  children,
+}) => {
+  const [user, setUser] = useState<MockUser | null>(null);
+  const [token, setToken] = useState<string | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    // Simulate checking for stored auth data
+    const checkAuth = () => {
+      try {
+        const storedToken = localStorage.getItem("mock_token");
+        const storedUser = localStorage.getItem("mock_user");
+
+        if (storedToken && storedUser) {
+          const parsedUser = JSON.parse(storedUser);
+          setToken(storedToken);
+          setUser(parsedUser);
+        }
+      } catch (error) {
+        console.error("Error checking mock auth:", error);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    if (typeof window !== "undefined") {
+      checkAuth();
+    } else {
+      setLoading(false);
+    }
+  }, []);
+
+  const login = async (email: string, password: string) => {
+    // Mock login - accept any credentials
+    const mockUser: MockUser = {
+      id: 1,
+      name: "Test User",
+      email: email,
+      role: "user",
+      isEmailVerified: true,
+      isWalletVerified: false,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const mockToken = "mock_jwt_token_" + Date.now();
+
+    setToken(mockToken);
+    setUser(mockUser);
+    localStorage.setItem("mock_token", mockToken);
+    localStorage.setItem("mock_user", JSON.stringify(mockUser));
+  };
+
+  const register = async (
+    name: string,
+    email: string,
+    password: string,
+    role: string
+  ) => {
+    // Mock registration
+    const mockUser: MockUser = {
+      id: 1,
+      name: name,
+      email: email,
+      role: role,
+      isEmailVerified: true,
+      isWalletVerified: false,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const mockToken = "mock_jwt_token_" + Date.now();
+
+    setToken(mockToken);
+    setUser(mockUser);
+    localStorage.setItem("mock_token", mockToken);
+    localStorage.setItem("mock_user", JSON.stringify(mockUser));
+  };
+
+  const logout = async () => {
+    setToken(null);
+    setUser(null);
+    localStorage.removeItem("mock_token");
+    localStorage.removeItem("mock_user");
+  };
+
+  return (
+    <MockAuthContext.Provider
+      value={{
+        user,
+        token,
+        isAuthenticated: !!token,
+        login,
+        register,
+        logout,
+        loading,
+        isLoading: loading,
+        hasPermission: (permission: Permission) => {
+          // Mock - always return true for testing
+          return true;
+        },
+      }}
+    >
+      {children}
+    </MockAuthContext.Provider>
+  );
+};
+
+export const useMockAuth = () => {
+  const context = useContext(MockAuthContext);
+  if (context === undefined) {
+    throw new Error("useMockAuth must be used within a MockAuthProvider");
+  }
+  return context;
+};
diff --git a/paystell-frontend/src/services/deposit.service.ts b/paystell-frontend/src/services/deposit.service.ts
new file mode 100644
index 0000000..8aac135
--- /dev/null
+++ b/paystell-frontend/src/services/deposit.service.ts
@@ -0,0 +1,176 @@
+import axios from 'axios';
+
+// Create axios instance with default config
+const api = axios.create({
+  baseURL: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+// Add request interceptor to add auth token
+api.interceptors.request.use((config) => {
+  const token = localStorage.getItem('token');
+  if (token) {
+    config.headers.Authorization = `Bearer ${token}`;
+  }
+  return config;
+});
+
+// Add response interceptor to handle errors
+api.interceptors.response.use(
+  (response) => response,
+  (error) => {
+    if (error.response?.status === 401) {
+      // Clear invalid token
+      localStorage.removeItem('token');
+      localStorage.removeItem('user');
+      // Handle unauthorized error (e.g., redirect to login)
+      window.location.href = '/login';
+    }
+    return Promise.reject(error);
+  }
+);
+
+export interface CreateDepositRequest {
+  amount?: string;
+  asset: string;
+  memo?: string;
+  customAddress?: string;
+}
+
+export interface DepositResponse {
+  success: boolean;
+  deposit: unknown;
+  message?: string;
+}
+
+export interface DepositsResponse {
+  success: boolean;
+  deposits: unknown[];
+  total: number;
+}
+
+export interface MonitoringConfig {
+  address: string;
+  asset: string;
+  minAmount?: string;
+  maxAmount?: string;
+  memo?: string;
+}
+
+export interface MonitoringResponse {
+  success: boolean;
+  config?: MonitoringConfig;
+  configs?: MonitoringConfig[];
+  total?: number;
+  message?: string;
+}
+
+export const createDepositRequest = async (data: CreateDepositRequest): Promise<DepositResponse> => {
+  try {
+    const response = await api.post('/api/deposit', data);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      throw new Error(error.response?.data?.message || 'Failed to create deposit request');
+    }
+    throw error;
+  }
+};
+
+export const getDepositRequests = async (userId?: string, status?: string): Promise<DepositsResponse> => {
+  try {
+    const params = new URLSearchParams();
+    if (userId) params.append('userId', userId);
+    if (status) params.append('status', status);
+    
+    const response = await api.get(`/api/deposit?${params.toString()}`);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      throw new Error(error.response?.data?.message || 'Failed to get deposit requests');
+    }
+    throw error;
+  }
+};
+
+export const getDepositRequest = async (id: string): Promise<DepositResponse> => {
+  try {
+    const response = await api.get(`/api/deposit/${id}`);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      throw new Error(error.response?.data?.message || 'Failed to get deposit request');
+    }
+    throw error;
+  }
+};
+
+export const updateDepositRequest = async (id: string, updates: Record<string, unknown>): Promise<DepositResponse> => {
+  try {
+    const response = await api.put(`/api/deposit/${id}`, updates);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      throw new Error(error.response?.data?.message || 'Failed to update deposit request');
+    }
+    throw error;
+  }
+};
+
+export const deleteDepositRequest = async (id: string): Promise<DepositResponse> => {
+  try {
+    const response = await api.delete(`/api/deposit/${id}`);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      throw new Error(error.response?.data?.message || 'Failed to delete deposit request');
+    }
+    throw error;
+  }
+};
+
+export const startMonitoring = async (config: MonitoringConfig): Promise<MonitoringResponse> => {
+  try {
+    const response = await api.post('/api/deposit/monitor', config);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      throw new Error(error.response?.data?.message || 'Failed to start monitoring');
+    }
+    throw error;
+  }
+};
+
+export const getMonitoringConfigs = async (address?: string, asset?: string): Promise<MonitoringResponse> => {
+  try {
+    const params = new URLSearchParams();
+    if (address) params.append('address', address);
+    if (asset) params.append('asset', asset);
+    
+    const response = await api.get(`/api/deposit/monitor?${params.toString()}`);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      throw new Error(error.response?.data?.message || 'Failed to get monitoring configs');
+    }
+    throw error;
+  }
+};
+
+export const stopMonitoring = async (address: string, asset: string): Promise<MonitoringResponse> => {
+  try {
+    const params = new URLSearchParams();
+    params.append('address', address);
+    params.append('asset', asset);
+    
+    const response = await api.delete(`/api/deposit/monitor?${params.toString()}`);
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      throw new Error(error.response?.data?.message || 'Failed to stop monitoring');
+    }
+    throw error;
+  }
+};