diff --git a/1 b/1
deleted file mode 100644
index e69de29b..00000000
diff --git a/apps/backend/database/migrations/00006_add_atomic_functions.sql b/apps/backend/database/migrations/00006_add_atomic_functions.sql
new file mode 100644
index 00000000..840c4989
--- /dev/null
+++ b/apps/backend/database/migrations/00006_add_atomic_functions.sql
@@ -0,0 +1,95 @@
+-- Migration: Add atomic functions for sync operations
+-- This migration adds PostgreSQL functions for atomic event processing
+-- to prevent inconsistent states when event logging or state updates fail.
+
+-- Ensure sync_events table has necessary constraints
+ALTER TABLE public.sync_events
+ADD CONSTRAINT IF NOT EXISTS sync_events_event_id_unique UNIQUE (event_id);
+
+-- Function for processing sync events atomically
+-- This function handles event insertion, booking status updates, and event marking in a single transaction
+CREATE OR REPLACE FUNCTION process_sync_event_atomic(
+    p_event_id TEXT,
+    p_event_type TEXT,
+    p_booking_id TEXT,
+    p_property_id TEXT,
+    p_user_id TEXT,
+    p_event_data JSONB,
+    p_new_status TEXT DEFAULT NULL
+)
+RETURNS JSONB
+LANGUAGE plpgsql
+SECURITY DEFINER
+AS $$
+DECLARE
+    v_sync_event_id UUID;
+BEGIN
+    -- Step 1: Insert sync event (with duplicate check)
+    INSERT INTO public.sync_events (event_id, event_type, booking_id, property_id, user_id, event_data, processed, created_at)
+    VALUES (p_event_id, p_event_type, p_booking_id, p_property_id, p_user_id, p_event_data, false, now())
+    ON CONFLICT (event_id) DO NOTHING
+    RETURNING id INTO v_sync_event_id;
+
+    -- If event already exists (duplicate), return early
+    IF v_sync_event_id IS NULL THEN
+        RETURN jsonb_build_object('success', false, 'error', 'DUPLICATE_EVENT', 'event_id', p_event_id);
+    END IF;
+
+    -- Step 2: Update booking status if applicable
+    IF p_new_status IS NOT NULL AND p_booking_id IS NOT NULL THEN
+        UPDATE public.bookings
+        SET status = p_new_status, updated_at = now()
+        WHERE escrow_address = p_booking_id OR blockchain_booking_id = p_booking_id;
+    END IF;
+
+    -- Step 3: Mark event as processed
+    UPDATE public.sync_events
+    SET processed = true, processed_at = now()
+    WHERE id = v_sync_event_id;
+
+    -- Log success
+    INSERT INTO public.sync_logs (operation, status, message, data, created_at)
+    VALUES (
+        'process_sync_event_atomic',
+        'success',
+        'Event processed atomically',
+        jsonb_build_object(
+            'event_id', p_event_id,
+            'event_type', p_event_type,
+            'booking_id', p_booking_id,
+            'new_status', p_new_status
+        ),
+        now()
+    );
+
+    RETURN jsonb_build_object(
+        'success', true,
+        'sync_event_id', v_sync_event_id,
+        'event_id', p_event_id
+    );
+
+EXCEPTION WHEN OTHERS THEN
+    -- Log error
+    INSERT INTO public.sync_logs (operation, status, error_details, created_at)
+    VALUES (
+        'process_sync_event_atomic',
+        'error',
+        jsonb_build_object(
+            'error', SQLERRM,
+            'error_state', SQLSTATE,
+            'event_id', p_event_id,
+            'event_type', p_event_type
+        ),
+        now()
+    );
+    -- Re-raise the exception to rollback the transaction
+    RAISE;
+END;
+$$;
+
+-- Grant execute permission to authenticated users
+GRANT EXECUTE ON FUNCTION process_sync_event_atomic(TEXT, TEXT, TEXT, TEXT, TEXT, JSONB, TEXT) TO authenticated;
+GRANT EXECUTE ON FUNCTION process_sync_event_atomic(TEXT, TEXT, TEXT, TEXT, TEXT, JSONB, TEXT) TO service_role;
+
+-- Add comment for documentation
+COMMENT ON FUNCTION process_sync_event_atomic IS 'Atomically processes blockchain sync events: inserts event, updates booking status, and marks as processed in a single transaction.';
diff --git a/apps/backend/database/migrations/00007_add_payment_constraints.sql b/apps/backend/database/migrations/00007_add_payment_constraints.sql
new file mode 100644
index 00000000..3610577f
--- /dev/null
+++ b/apps/backend/database/migrations/00007_add_payment_constraints.sql
@@ -0,0 +1,132 @@
+-- Migration: Add payment validation constraints and atomic confirmation function
+-- This migration prevents duplicate transaction hash usage and ensures atomic payment confirmation.
+
+-- Unique constraint to prevent the same transaction hash being used for multiple bookings
+CREATE UNIQUE INDEX IF NOT EXISTS bookings_payment_tx_hash_unique_idx
+ON public.bookings (payment_transaction_hash)
+WHERE payment_transaction_hash IS NOT NULL;
+
+-- RPC function for atomic booking payment confirmation with validations
+CREATE OR REPLACE FUNCTION confirm_booking_payment_atomic(
+    p_booking_id UUID,
+    p_transaction_hash TEXT
+)
+RETURNS JSONB
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    v_booking RECORD;
+BEGIN
+    -- Validate transaction hash is provided
+    IF p_transaction_hash IS NULL OR p_transaction_hash = '' THEN
+        RETURN jsonb_build_object(
+            'success', false,
+            'error', 'INVALID_TRANSACTION_HASH',
+            'message', 'Transaction hash is required'
+        );
+    END IF;
+
+    -- Lock the booking row for update to prevent concurrent modifications
+    SELECT id, status, payment_transaction_hash
+    INTO v_booking
+    FROM public.bookings
+    WHERE id = p_booking_id
+    FOR UPDATE;
+
+    -- Check if booking exists
+    IF v_booking IS NULL THEN
+        RETURN jsonb_build_object(
+            'success', false,
+            'error', 'NOT_FOUND',
+            'message', 'Booking not found'
+        );
+    END IF;
+
+    -- Check if booking is already paid
+    IF v_booking.payment_transaction_hash IS NOT NULL THEN
+        RETURN jsonb_build_object(
+            'success', false,
+            'error', 'ALREADY_PAID',
+            'message', 'Booking has already been paid',
+            'existing_hash', v_booking.payment_transaction_hash
+        );
+    END IF;
+
+    -- Check if transaction hash is already used by another booking
+    IF EXISTS (
+        SELECT 1 FROM public.bookings
+        WHERE payment_transaction_hash = p_transaction_hash
+        AND id != p_booking_id
+    ) THEN
+        RETURN jsonb_build_object(
+            'success', false,
+            'error', 'DUPLICATE_TRANSACTION',
+            'message', 'Transaction hash is already used by another booking'
+        );
+    END IF;
+
+    -- Update the booking with payment confirmation
+    UPDATE public.bookings
+    SET
+        status = 'confirmed',
+        payment_transaction_hash = p_transaction_hash,
+        paid_at = now(),
+        updated_at = now()
+    WHERE id = p_booking_id;
+
+    -- Log the successful payment confirmation
+    INSERT INTO public.sync_logs (operation, status, message, data, created_at)
+    VALUES (
+        'confirm_booking_payment_atomic',
+        'success',
+        'Payment confirmed atomically',
+        jsonb_build_object(
+            'booking_id', p_booking_id,
+            'transaction_hash', p_transaction_hash
+        ),
+        now()
+    );
+
+    RETURN jsonb_build_object(
+        'success', true,
+        'booking_id', p_booking_id,
+        'transaction_hash', p_transaction_hash,
+        'status', 'confirmed'
+    );
+
+EXCEPTION WHEN unique_violation THEN
+    -- Handle the case where another process inserted the same tx hash concurrently
+    RETURN jsonb_build_object(
+        'success', false,
+        'error', 'DUPLICATE_TRANSACTION',
+        'message', 'Transaction hash was just used by another booking (concurrent update)'
+    );
+WHEN OTHERS THEN
+    -- Log error and return failure
+    INSERT INTO public.sync_logs (operation, status, error_details, created_at)
+    VALUES (
+        'confirm_booking_payment_atomic',
+        'error',
+        jsonb_build_object(
+            'error', SQLERRM,
+            'error_state', SQLSTATE,
+            'booking_id', p_booking_id::text,
+            'transaction_hash', p_transaction_hash
+        ),
+        now()
+    );
+
+    RETURN jsonb_build_object(
+        'success', false,
+        'error', 'DB_ERROR',
+        'message', SQLERRM
+    );
+END;
+$$;
+
+-- Grant execute permission
+GRANT EXECUTE ON FUNCTION confirm_booking_payment_atomic(UUID, TEXT) TO authenticated;
+GRANT EXECUTE ON FUNCTION confirm_booking_payment_atomic(UUID, TEXT) TO service_role;
+
+-- Add comment for documentation
+COMMENT ON FUNCTION confirm_booking_payment_atomic IS 'Atomically confirms a booking payment with validation: checks booking exists, is not already paid, and transaction hash is not reused.';
diff --git a/apps/backend/src/blockchain/eventListener.ts b/apps/backend/src/blockchain/eventListener.ts
index abb1f514..37b9bb4a 100644
--- a/apps/backend/src/blockchain/eventListener.ts
+++ b/apps/backend/src/blockchain/eventListener.ts
@@ -1,7 +1,8 @@
-import { Contract, Networks, rpc, xdr } from '@stellar/stellar-sdk';
+import { Contract } from '@stellar/stellar-sdk';
 import { Server as SorobanRpcServer } from '@stellar/stellar-sdk/rpc';
 import { supabase } from '../config/supabase';
 import { loggingService } from '../services/logging.service';
+import { syncService } from '../services/sync.service';
 
 export interface BlockchainEvent {
   id: string;
@@ -118,7 +119,15 @@ export class BlockchainEventListener {
 
       console.log(`Initialized event listener at ledger ${this.lastProcessedLedger}`);
     } catch (error) {
-      console.warn('Could not initialize last processed ledger, starting from current:', error);
+      const errorLog = await loggingService.logBlockchainOperation(
+        'initializeLastProcessedLedger',
+        {}
+      );
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Could not initialize last processed ledger from database, starting from current',
+      });
+      // Fallback to current ledger
       this.lastProcessedLedger = await this.getCurrentLedger();
     }
   }
@@ -131,7 +140,14 @@ export class BlockchainEventListener {
       const ledgerInfo = await this.server.getLatestLedger();
       return ledgerInfo.sequence || 0;
     } catch (error) {
-      console.error('Failed to get current ledger:', error);
+      const errorLog = await loggingService.logBlockchainOperation('getCurrentLedger', {
+        lastProcessedLedger: this.lastProcessedLedger,
+      });
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Failed to get current ledger from Stellar network',
+      });
+      // Return last processed ledger as fallback to allow processing to continue
       return this.lastProcessedLedger;
     }
   }
@@ -176,7 +192,15 @@ export class BlockchainEventListener {
           await this.processEvent(event);
         }
       } catch (error) {
-        console.error(`Error processing ledger ${ledger}:`, error);
+        const errorLog = await loggingService.logBlockchainOperation('processLedgers', {
+          ledger,
+          fromLedger,
+          toLedger,
+        });
+        await loggingService.logBlockchainError(errorLog, {
+          error,
+          context: `Error processing ledger ${ledger}, continuing with next ledger`,
+        });
         // Continue with next ledger instead of failing completely
       }
     }
@@ -217,7 +241,15 @@ export class BlockchainEventListener {
 
       return events;
     } catch (error) {
-      console.error(`Failed to get events from ledger ${ledger}:`, error);
+      const errorLog = await loggingService.logBlockchainOperation('getEventsFromLedger', {
+        ledger,
+        contractId: this.config.contractId,
+      });
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: `Failed to get events from ledger ${ledger}`,
+      });
+      // Return empty array to allow processing to continue with next ledger
       return [];
     }
   }
@@ -249,7 +281,24 @@ export class BlockchainEventListener {
         data: eventData,
       };
     } catch (error) {
-      console.error('Error parsing Soroban event:', error);
+      // Log parsing errors but don't block processing
+      // Using fire-and-forget logging to avoid blocking the event loop
+      loggingService
+        .logBlockchainOperation('parseSorobanEvent', {
+          ledger,
+          txHash: event.txHash,
+        })
+        .then((errorLog) => {
+          loggingService.logBlockchainError(errorLog, {
+            error,
+            context: 'Error parsing Soroban event, skipping event',
+          });
+        })
+        .catch((loggingError) => {
+          // Fallback to console if logging service fails
+          console.error('Failed to log parseSorobanEvent error:', loggingError);
+          console.error('Original parsing error:', error);
+        });
       return null;
     }
   }
@@ -272,7 +321,21 @@ export class BlockchainEventListener {
       // Return empty object if no data found
       return {};
     } catch (error) {
-      console.error('Error parsing Soroban event data:', error);
+      // Log parsing errors but don't block processing
+      // Using fire-and-forget logging to avoid blocking the event loop
+      loggingService
+        .logBlockchainOperation('parseSorobanEventData', {})
+        .then((errorLog) => {
+          loggingService.logBlockchainError(errorLog, {
+            error,
+            context: 'Error parsing Soroban event data, returning empty object',
+          });
+        })
+        .catch((loggingError) => {
+          // Fallback to console if logging service fails
+          console.error('Failed to log parseSorobanEventData error:', loggingError);
+          console.error('Original parsing error:', error);
+        });
       return {};
     }
   }
@@ -296,55 +359,180 @@ export class BlockchainEventListener {
           return null;
       }
     } catch (error) {
-      console.error('Error determining event type:', error);
+      // Log parsing errors but don't block processing
+      // Using fire-and-forget logging to avoid blocking the event loop
+      loggingService
+        .logBlockchainOperation('determineEventType', {
+          eventName: event.name ?? event.type,
+        })
+        .then((errorLog) => {
+          loggingService.logBlockchainError(errorLog, {
+            error,
+            context: 'Error determining event type, skipping event',
+          });
+        })
+        .catch((loggingError) => {
+          // Fallback to console if logging service fails
+          console.error('Failed to log determineEventType error:', loggingError);
+          console.error('Original parsing error:', error);
+        });
       return null;
     }
   }
 
   /**
-   * Process a single blockchain event
+   * Check if event has already been processed (duplicate check)
+   */
+  private async isEventAlreadyProcessed(eventId: string): Promise<boolean> {
+    try {
+      const { data, error } = await supabase
+        .from('sync_events')
+        .select('id, processed')
+        .eq('event_id', eventId)
+        .single();
+
+      if (error && error.code !== 'PGRST116') {
+        // PGRST116 is "not found" which is expected for new events
+        // Other errors should be logged but not block processing
+        const errorLog = await loggingService.logBlockchainOperation('isEventAlreadyProcessed', {
+          eventId,
+        });
+        await loggingService.logBlockchainError(errorLog, {
+          error,
+          context: 'Error checking for duplicate event',
+        });
+      }
+
+      return data !== null && data !== undefined;
+    } catch (error) {
+      // Log error but don't block processing - let the atomic function handle duplicates
+      const errorLog = await loggingService.logBlockchainOperation('isEventAlreadyProcessed', {
+        eventId,
+      });
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Exception checking for duplicate event',
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Determine the new status for an event type
+   */
+  private getStatusForEventType(eventType: string): string | undefined {
+    switch (eventType) {
+      case 'booking_cancelled':
+        return 'cancelled';
+      case 'payment_confirmed':
+        return 'confirmed';
+      default:
+        return undefined;
+    }
+  }
+
+  /**
+   * Process a single blockchain event atomically
    */
   private async processEvent(event: BlockchainEvent): Promise<void> {
     try {
-      const logId = await loggingService.logBlockchainOperation('processEvent', { event });
+      const logId = await loggingService.logBlockchainOperation('processEvent', {
+        eventId: event.id,
+        eventType: event.type,
+        txHash: event.transactionHash,
+      });
 
-      // Store event in database
-      await this.storeEvent(event);
+      // Validate transaction ID before processing (explicit duplicate check)
+      const isDuplicate = await this.isEventAlreadyProcessed(event.id);
+      if (isDuplicate) {
+        await loggingService.logBlockchainSuccess(logId, {
+          eventId: event.id,
+          skipped: true,
+          reason: 'duplicate_event_detected_before_processing',
+        });
+        return;
+      }
+
+      // Determine new status if applicable
+      const newStatus = this.getStatusForEventType(event.type);
+
+      // Process event atomically (insert, update status if applicable, mark as processed)
+      const result = await syncService.processEventAtomic(
+        event.id,
+        event.type,
+        event.bookingId || null,
+        event.propertyId || null,
+        event.userId || 'unknown',
+        {
+          ...event.data,
+          blockHeight: event.blockHeight,
+          transactionHash: event.transactionHash,
+          timestamp: event.timestamp.toISOString(),
+        },
+        newStatus
+      );
+
+      // Handle duplicate event (detected during atomic processing)
+      if (result.error === 'DUPLICATE_EVENT') {
+        await loggingService.logBlockchainSuccess(logId, {
+          eventId: event.id,
+          skipped: true,
+          reason: 'duplicate_event_detected_during_atomic_processing',
+        });
+        return;
+      }
 
-      // Call registered callbacks
+      // Call registered callbacks after atomic processing
+      // These should be idempotent and handle their own errors
       const callback = this.eventCallbacks.get(event.type);
       if (callback) {
-        await callback(event);
+        try {
+          await callback(event);
+        } catch (callbackError) {
+          // Log callback errors but don't fail the event processing
+          // since the atomic processing already succeeded
+          const callbackErrorLog = await loggingService.logBlockchainOperation(
+            'processEvent_callback',
+            {
+              eventId: event.id,
+              eventType: event.type,
+            }
+          );
+          await loggingService.logBlockchainError(callbackErrorLog, {
+            error: callbackError,
+            context: 'Callback execution failed after atomic event processing',
+          });
+        }
       }
 
       // Log success
-      await loggingService.logBlockchainSuccess(logId, { eventId: event.id });
+      await loggingService.logBlockchainSuccess(logId, {
+        eventId: event.id,
+        syncEventId: result.syncEventId,
+      });
     } catch (error) {
-      console.error(`Error processing event ${event.id}:`, error);
+      const errorLog = await loggingService.logBlockchainOperation('processEvent', {
+        eventId: event.id,
+        eventType: event.type,
+      });
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Failed to process blockchain event',
+      });
       await this.markEventFailed(event.id, error as Error);
-      loggingService.logBlockchainError('processEvent', error as Error);
+      throw error;
     }
   }
 
   /**
    * Store event in database
+   * @deprecated This method is no longer used. Events are stored atomically via processEventAtomic.
+   * Kept for reference but should not be called.
    */
-  private async storeEvent(event: BlockchainEvent): Promise<void> {
-    await supabase.from('sync_events').insert({
-      event_id: event.id,
-      event_type: event.type,
-      booking_id: event.bookingId,
-      property_id: event.propertyId,
-      user_id: event.userId,
-      event_data: {
-        ...event.data,
-        blockHeight: event.blockHeight,
-        transactionHash: event.transactionHash,
-        timestamp: event.timestamp.toISOString(),
-      },
-      processed: false,
-      created_at: new Date().toISOString(),
-    });
+  private async storeEvent(_event: BlockchainEvent): Promise<void> {
+    // This method is deprecated - events are now stored atomically via processEventAtomic
+    // Keeping for backward compatibility but it should not be called
+    console.warn('storeEvent is deprecated - use processEventAtomic instead');
   }
 
   /**
diff --git a/apps/backend/src/blockchain/trustlessWork.ts b/apps/backend/src/blockchain/trustlessWork.ts
index e7a898e0..03710e2f 100644
--- a/apps/backend/src/blockchain/trustlessWork.ts
+++ b/apps/backend/src/blockchain/trustlessWork.ts
@@ -1,5 +1,6 @@
 import { Keypair } from '@stellar/stellar-sdk';
 import axios, { type AxiosResponse } from 'axios';
+import { EscrowError } from '../types/errors';
 
 const TRUSTLESS_WORK_API_URL =
   process.env.TRUSTLESS_WORK_API_URL || 'https://api.trustlesswork.com';
@@ -304,8 +305,7 @@ export async function createEscrow(params: BookingEscrowParams): Promise<string>
 
     return response.escrowAddress;
   } catch (error) {
-    console.error('Error creating escrow:', error);
-    throw new Error('Failed to create escrow');
+    throw new EscrowError('Failed to create escrow', 'CREATE_ESCROW_FAIL', error);
   }
 }
 
@@ -349,50 +349,46 @@ export class EscrowManager {
   }
 
   async isEscrowReady(escrowId: string): Promise<boolean> {
-    try {
-      const status = await this.client.getEscrowStatus(escrowId);
-      return status.status === 'created' || status.status === 'pending';
-    } catch (error) {
-      console.error('Error checking escrow status:', error);
-      return false;
-    }
+    const status = await this.client.getEscrowStatus(escrowId);
+    return status.status === 'created' || status.status === 'pending';
   }
 
-  async getEscrowDetails(escrowId: string): Promise<EscrowStatus | null> {
-    try {
-      return await this.client.getEscrowStatus(escrowId);
-    } catch (error) {
-      console.error('Error fetching escrow details:', error);
-      return null;
-    }
+  async getEscrowDetails(escrowId: string): Promise<EscrowStatus> {
+    return await this.client.getEscrowStatus(escrowId);
   }
 
   async releasePayment(escrowId: string, amount?: number): Promise<boolean> {
-    try {
-      const result = await this.client.releaseEscrow({
+    const result = await this.client.releaseEscrow({
+      escrowId,
+      amount: amount?.toFixed(2),
+      reason: 'Successful check-in completed',
+    });
+
+    if (!result.success) {
+      throw new EscrowError('Failed to release payment', 'RELEASE_PAYMENT_FAIL', {
         escrowId,
-        amount: amount?.toFixed(2),
-        reason: 'Successful check-in completed',
+        amount,
       });
-      return result.success;
-    } catch (error) {
-      console.error('Error releasing payment:', error);
-      return false;
     }
+
+    return result.success;
   }
 
   async releaseDeposit(escrowId: string, amount?: number): Promise<boolean> {
-    try {
-      const result = await this.client.releaseEscrow({
+    const result = await this.client.releaseEscrow({
+      escrowId,
+      amount: amount?.toFixed(2),
+      reason: 'Successful checkout, no damages',
+    });
+
+    if (!result.success) {
+      throw new EscrowError('Failed to release deposit', 'RELEASE_DEPOSIT_FAIL', {
         escrowId,
-        amount: amount?.toFixed(2),
-        reason: 'Successful checkout, no damages',
+        amount,
       });
-      return result.success;
-    } catch (error) {
-      console.error('Error releasing deposit:', error);
-      return false;
     }
+
+    return result.success;
   }
 }
 
diff --git a/apps/backend/src/controllers/wallet-auth.controller.ts b/apps/backend/src/controllers/wallet-auth.controller.ts
deleted file mode 100644
index 2316a9f2..00000000
--- a/apps/backend/src/controllers/wallet-auth.controller.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import type { Request, Response } from 'express';
-import { authenticateWallet } from '../services/wallet-auth.service';
-import { generateChallenge as generateWalletChallenge } from '../services/wallet-challenge.service';
-import type { ChallengeRequest, WalletLoginRequest } from '../types/wallet-auth.types';
-import {
-  ConnectionRejectedError,
-  InvalidChallengeError,
-  InvalidPublicKeyError,
-  SignatureVerificationError,
-  WalletNotFoundError,
-} from '../types/wallet-error-types';
-
-//===================
-// Generate challenge for wallet authentication
-//===================
-export const generateChallenge = async (req: Request, res: Response) => {
-  try {
-    const { publicKey } = req.body as ChallengeRequest;
-
-    const challengeResponse = await generateWalletChallenge(publicKey);
-
-    res.status(200).json(challengeResponse);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    res.status(500).json({ error: message });
-  }
-};
-
-//===================
-// Authenticate wallet with signed transaction
-//===================
-export const authenticateWalletController = async (req: Request, res: Response) => {
-  try {
-    const walletLoginData = req.body as WalletLoginRequest;
-
-    if (!walletLoginData.publicKey) {
-      return res.status(400).json({ error: 'Missing publicKey' });
-    }
-    if (!walletLoginData.signedTransaction) {
-      return res.status(400).json({ error: 'Missing signedTransaction' });
-    }
-    if (!walletLoginData.challenge) {
-      return res.status(400).json({ error: 'Missing challenge' });
-    }
-
-    const authResponse = await authenticateWallet(walletLoginData);
-
-    res.cookie('auth-token', authResponse.token, {
-      httpOnly: true,
-      secure: process.env.NODE_ENV === 'production',
-      sameSite: 'strict',
-      maxAge: 7 * 24 * 60 * 60 * 1000,
-    });
-
-    console.log('🎉 Wallet authentication successful for user:', authResponse.user.id);
-    res.status(200).json({
-      user: authResponse.user,
-      token: authResponse.token,
-    });
-  } catch (error) {
-    console.error('Wallet authentication error:', error);
-
-    if (error instanceof InvalidPublicKeyError) {
-      return res.status(400).json({ error: error.message, code: 'INVALID_PUBLIC_KEY' });
-    }
-
-    if (error instanceof InvalidChallengeError) {
-      return res.status(401).json({ error: error.message, code: 'INVALID_CHALLENGE' });
-    }
-
-    if (error instanceof SignatureVerificationError) {
-      return res.status(401).json({ error: error.message, code: 'SIGNATURE_VERIFICATION_FAILED' });
-    }
-
-    if (error instanceof WalletNotFoundError) {
-      return res.status(400).json({ error: error.message, code: 'WALLET_NOT_FOUND' });
-    }
-
-    if (error instanceof ConnectionRejectedError) {
-      return res.status(400).json({ error: error.message, code: 'CONNECTION_REJECTED' });
-    }
-
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    res.status(500).json({ error: message, code: 'INTERNAL_ERROR' });
-  }
-};
diff --git a/apps/backend/src/index.ts b/apps/backend/src/index.ts
index f7d80f30..27632f15 100644
--- a/apps/backend/src/index.ts
+++ b/apps/backend/src/index.ts
@@ -8,7 +8,7 @@ import { rateLimiter } from './middleware/rateLimiter';
 import { locationRoutes, profileRoutes, propertyRoutes } from './routes';
 import authRoutes from './routes/auth';
 import bookingRoutes from './routes/booking.routes';
-import walletAuthRoutes from './routes/wallet-auth.routes';
+// wallet-auth routes removed - replaced by client-side Stellar Social SDK
 
 import { connectRedis } from './config/redis';
 import syncRoutes from './routes/sync.routes';
@@ -89,7 +89,7 @@ app.use(rateLimiter);
 
 // Routes
 app.use('/auth', authRoutes);
-app.use('/api/auth', walletAuthRoutes);
+// wallet-auth endpoint removed - authentication now handled by client-side Stellar Social SDK
 app.use('/api/bookings', bookingRoutes);
 app.use('/api/locations', locationRoutes);
 app.use('/api/profile', profileRoutes);
diff --git a/apps/backend/src/middleware/error.middleware.ts b/apps/backend/src/middleware/error.middleware.ts
index 9fa0e7d9..b8aeea7e 100644
--- a/apps/backend/src/middleware/error.middleware.ts
+++ b/apps/backend/src/middleware/error.middleware.ts
@@ -1,12 +1,38 @@
 import type { ErrorRequestHandler } from 'express';
 import { JsonWebTokenError, TokenExpiredError } from 'jsonwebtoken';
 import { ZodError } from 'zod';
+import { BookingError } from '../types/common.types';
+import { EscrowError, SyncError } from '../types/errors';
 
 interface ErrorResponse {
   error: string;
-  details?: Array<{ path?: string; message: string }>;
+  code?: string;
+  details?: Array<{ path?: string; message: string }> | unknown;
 }
 
+// Map error codes to HTTP status codes
+const errorCodeToStatus: Record<string, number> = {
+  NOT_FOUND: 404,
+  UNAUTHORIZED: 401,
+  ALREADY_PAID: 409,
+  DUPLICATE_TRANSACTION: 409,
+  DUPLICATE_EVENT: 409,
+  UNAVAILABLE: 409,
+  INVALID_STATUS: 400,
+  INVALID_BUYER_WALLET: 400,
+  INVALID_SELLER_WALLET: 400,
+  DB_ERROR: 500,
+  BLOCKCHAIN_FAIL: 502,
+  CREATE_ESCROW_FAIL: 502,
+  ESCROW_CANCEL_FAIL: 502,
+  RELEASE_PAYMENT_FAIL: 502,
+  RELEASE_DEPOSIT_FAIL: 502,
+  SYNC_FAIL: 502,
+  ATOMIC_PROCESS_FAIL: 500,
+  POLL_EVENTS_FAIL: 502,
+  GET_EVENTS_FAIL: 502,
+};
+
 export const errorMiddleware: ErrorRequestHandler = (err, _req, res, _next) => {
   // Only log full stack traces in development
   if (process.env.NODE_ENV !== 'production') {
@@ -31,6 +57,27 @@ export const errorMiddleware: ErrorRequestHandler = (err, _req, res, _next) => {
   } else if (err instanceof TokenExpiredError) {
     statusCode = 401;
     response.error = 'Token expired';
+  } else if (err instanceof BookingError) {
+    statusCode = errorCodeToStatus[err.code] || 400;
+    response.error = err.message;
+    response.code = err.code;
+    if (err.details && process.env.NODE_ENV !== 'production') {
+      response.details = err.details;
+    }
+  } else if (err instanceof EscrowError) {
+    statusCode = errorCodeToStatus[err.code] || 502;
+    response.error = err.message;
+    response.code = err.code;
+    if (err.details && process.env.NODE_ENV !== 'production') {
+      response.details = err.details;
+    }
+  } else if (err instanceof SyncError) {
+    statusCode = errorCodeToStatus[err.code] || 500;
+    response.error = err.message;
+    response.code = err.code;
+    if (err.details && process.env.NODE_ENV !== 'production') {
+      response.details = err.details;
+    }
   } else if (err.name === 'PostgrestError') {
     statusCode = 400;
     response.error = 'Database error';
diff --git a/apps/backend/src/routes/wallet-auth.routes.ts b/apps/backend/src/routes/wallet-auth.routes.ts
deleted file mode 100644
index c0d93a22..00000000
--- a/apps/backend/src/routes/wallet-auth.routes.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { Router } from 'express';
-import {
-  authenticateWalletController,
-  generateChallenge,
-} from '../controllers/wallet-auth.controller';
-import { challengeRateLimit, walletAuthRateLimit } from '../middleware/rateLimiter';
-import { validateChallengeRequest, validateWalletLogin } from '../validators/wallet-auth.validator';
-
-const router = Router();
-
-//===================
-// Generate challenge route for wallet authentication
-//===================
-router.post('/challenge', challengeRateLimit, validateChallengeRequest, generateChallenge);
-
-//===================
-// Authenticate with wallet signature route
-//===================
-router.post('/wallet', walletAuthRateLimit, validateWalletLogin, authenticateWalletController);
-
-export default router;
diff --git a/apps/backend/src/services/booking.service.ts b/apps/backend/src/services/booking.service.ts
index 1d1e029b..4adf48d9 100644
--- a/apps/backend/src/services/booking.service.ts
+++ b/apps/backend/src/services/booking.service.ts
@@ -1,7 +1,6 @@
 import { StrKey } from '@stellar/stellar-sdk';
 import {
   cancelBookingOnChain,
-  checkBookingAvailability,
   createBookingOnChain,
   updateBookingStatusOnChain,
 } from '../blockchain/bookingContract';
@@ -514,37 +513,64 @@ export const bookingService = new BookingService(blockchainServices);
 
 // Existing utility functions for payment confirmation and booking retrieval
 export async function confirmBookingPayment(bookingId: string, transactionHash: string) {
+  const log = await loggingService.logBlockchainOperation('confirmBookingPayment', {
+    bookingId,
+    transactionHash,
+  });
+
   try {
-    const { data: existingBooking, error: fetchError } = await supabase
-      .from('bookings')
-      .select('*')
-      .eq('id', bookingId)
-      .single();
+    // Use atomic RPC function to validate and confirm payment
+    const { data, error } = await supabase.rpc('confirm_booking_payment_atomic', {
+      p_booking_id: bookingId,
+      p_transaction_hash: transactionHash,
+    });
 
-    if (fetchError || !existingBooking) {
-      throw new BookingError('Booking not found or failed to retrieve', 'NOT_FOUND', fetchError);
+    if (error) {
+      await loggingService.logBlockchainError(log, { error, context: 'RPC call failed' });
+      throw new BookingError('Database error during payment confirmation', 'DB_ERROR', error);
     }
 
-    const { data, error } = await supabase
+    // Handle validation errors from the RPC function
+    if (!data.success) {
+      const errorMap: Record<string, [string, string]> = {
+        NOT_FOUND: ['Booking not found', 'NOT_FOUND'],
+        ALREADY_PAID: ['Booking has already been paid', 'ALREADY_PAID'],
+        DUPLICATE_TRANSACTION: [
+          'Transaction hash is already used by another booking',
+          'DUPLICATE_TRANSACTION',
+        ],
+        INVALID_TRANSACTION_HASH: ['Transaction hash is required', 'INVALID_TRANSACTION_HASH'],
+        DB_ERROR: ['Database error occurred', 'DB_ERROR'],
+      };
+      const [msg, code] = errorMap[data.error] || ['Payment confirmation failed', 'CONFIRM_FAIL'];
+      throw new BookingError(msg, code, data);
+    }
+
+    // Fetch the updated booking to return full data
+    const { data: booking, error: fetchError } = await supabase
       .from('bookings')
-      .update({
-        status: 'confirmed',
-        payment_transaction_hash: transactionHash,
-        paid_at: new Date().toISOString(),
-      })
+      .select('*')
       .eq('id', bookingId)
-      .select()
       .single();
 
-    if (error || !data) {
-      throw new BookingError('Failed to confirm booking status update', 'CONFIRM_FAIL', error);
+    if (fetchError || !booking) {
+      // Payment was confirmed but fetch failed - log but don't throw
+      await loggingService.logBlockchainError(log, {
+        error: fetchError,
+        context: 'Payment confirmed but failed to fetch updated booking',
+      });
+      // Return minimal data since confirmation was successful
+      return { id: bookingId, status: 'confirmed', payment_transaction_hash: transactionHash };
     }
-    return data;
+
+    await loggingService.logBlockchainSuccess(log, { booking });
+    return booking;
   } catch (error) {
     if (error instanceof BookingError) {
       throw error;
     }
-    throw new BookingError('Confirmation error', 'CONFIRM_FAIL', error);
+    await loggingService.logBlockchainError(log, { error, context: 'confirmBookingPayment' });
+    throw new BookingError('Payment confirmation failed', 'CONFIRM_FAIL', error);
   }
 }
 
diff --git a/apps/backend/src/services/cache.service.ts b/apps/backend/src/services/cache.service.ts
index e194f2ab..1dcb2534 100644
--- a/apps/backend/src/services/cache.service.ts
+++ b/apps/backend/src/services/cache.service.ts
@@ -1,5 +1,6 @@
 import crypto from 'node:crypto';
 import { type RedisClientType, createClient } from 'redis';
+import { loggingService } from './logging.service';
 
 export class CacheService {
   private client: RedisClientType;
@@ -74,7 +75,9 @@ export class CacheService {
       const data = await this.client.get(key);
       return data ? JSON.parse(data) : null;
     } catch (error) {
-      console.error('Cache get error:', error);
+      // Cache errors should be logged but not stop the application
+      const log = await loggingService.logBlockchainOperation('cache_get', { key });
+      await loggingService.logBlockchainError(log, { error, context: 'Cache get failed' });
       return null;
     }
   }
@@ -93,7 +96,9 @@ export class CacheService {
     try {
       await this.client.setEx(key, ttlSeconds, JSON.stringify(data));
     } catch (error) {
-      console.error('Cache set error:', error);
+      // Cache errors should be logged but not stop the application
+      const log = await loggingService.logBlockchainOperation('cache_set', { key, ttlSeconds });
+      await loggingService.logBlockchainError(log, { error, context: 'Cache set failed' });
     }
   }
 
@@ -109,7 +114,9 @@ export class CacheService {
     try {
       await this.client.del(key);
     } catch (error) {
-      console.error('Cache delete error:', error);
+      // Cache errors should be logged but not stop the application
+      const log = await loggingService.logBlockchainOperation('cache_delete', { key });
+      await loggingService.logBlockchainError(log, { error, context: 'Cache delete failed' });
     }
   }
 
@@ -128,7 +135,12 @@ export class CacheService {
         await this.client.del(keys);
       }
     } catch (error) {
-      console.error('Cache delete pattern error:', error);
+      // Cache errors should be logged but not stop the application
+      const log = await loggingService.logBlockchainOperation('cache_delete_pattern', { pattern });
+      await loggingService.logBlockchainError(log, {
+        error,
+        context: 'Cache delete pattern failed',
+      });
     }
   }
 
@@ -257,7 +269,9 @@ export class CacheService {
         keyCount,
       };
     } catch (error) {
-      console.error('Cache stats error:', error);
+      // Cache errors should be logged but not stop the application
+      const log = await loggingService.logBlockchainOperation('cache_stats', {});
+      await loggingService.logBlockchainError(log, { error, context: 'Cache stats failed' });
       return { isConnected: true };
     }
   }
diff --git a/apps/backend/src/services/sync.service.ts b/apps/backend/src/services/sync.service.ts
index 8be6746b..c8b39d87 100644
--- a/apps/backend/src/services/sync.service.ts
+++ b/apps/backend/src/services/sync.service.ts
@@ -1,29 +1,14 @@
-/**
- * Sync Service
- *
- * Provides blockchain synchronization capabilities for StellarRent.
- * Polls the Stellar network for new events and processes them accordingly.
- *
- * Environment Variables:
- * - SOROBAN_RPC_URL: Soroban RPC endpoint URL
- * - SOROBAN_CONTRACT_ID: Contract ID to monitor
- * - SOROBAN_NETWORK_PASSPHRASE: Network passphrase for validation
- * - SYNC_POLL_INTERVAL: Polling interval in milliseconds (default: 5000ms)
- *
- * Features:
- * - Configurable polling intervals
- * - Network passphrase validation
- * - Comprehensive error handling and logging
- * - Manual sync triggers
- * - Status monitoring and statistics
- */
-
-import { Contract, Networks, nativeToScVal, scValToNative } from '@stellar/stellar-sdk';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Contract, Networks } from '@stellar/stellar-sdk';
 import { Server as SorobanRpcServer } from '@stellar/stellar-sdk/rpc';
 import { supabase } from '../config/supabase';
+import { SyncError } from '../types/errors';
 import { bookingService } from './booking.service';
 import { loggingService } from './logging.service';
 
+const execAsync = promisify(exec);
+
 export interface SyncEvent {
   id: string;
   type:
@@ -292,11 +277,17 @@ export class SyncService {
 
       console.log(`Initialized sync state: last block ${this.lastProcessedBlock}`);
     } catch (error) {
-      console.warn('Could not initialize sync state, starting fresh:', error);
+      // Log error properly and reset state
+      const errorLog = await loggingService.logBlockchainOperation('initializeSyncState', {});
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Could not initialize sync state from database, starting fresh',
+      });
       this.lastProcessedBlock = 0;
       this.totalEventsProcessed = 0;
       this.failedEvents = 0;
       this.lastSyncTime = null;
+      // Don't rethrow - starting fresh is a valid fallback
     }
   }
 
@@ -327,18 +318,19 @@ export class SyncService {
         eventsProcessed: this.totalEventsProcessed,
       });
     } catch (error) {
-      console.error('Error polling for events:', error);
       this.failedEvents++;
 
-      // Log the error in sync_logs table instead of using loggingService
-      await supabase.from('sync_logs').insert({
-        operation: 'pollForEvents',
-        status: 'error',
-        message: 'Failed to poll for blockchain events',
-        error_details: {
-          error: error instanceof Error ? error.message : 'Unknown error',
-        },
+      // Log the error using loggingService for proper error serialization
+      const errorLog = await loggingService.logBlockchainOperation('pollForEvents', {
+        lastProcessedBlock: this.lastProcessedBlock,
+      });
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Failed to poll for blockchain events',
       });
+
+      // Re-throw as SyncError to propagate to callers
+      throw new SyncError('Failed to poll for blockchain events', 'POLL_EVENTS_FAIL', error);
     }
   }
 
@@ -466,9 +458,18 @@ export class SyncService {
       }
     }
 
-    console.warn(
-      `All ${maxRetries} attempts failed for both SDK and CLI methods. Using fallback block height: ${this.lastProcessedBlock}`
-    );
+    // Log the critical failure properly
+    const errorLog = await loggingService.logBlockchainOperation('getCurrentBlockHeight', {
+      maxRetries,
+      lastProcessedBlock: this.lastProcessedBlock,
+    });
+    await loggingService.logBlockchainError(errorLog, {
+      error: new Error(
+        `All ${maxRetries} attempts failed for both SDK and CLI methods. Using fallback block height.`
+      ),
+      context: 'Critical: Cannot get current block height from Stellar network',
+    });
+    // Return fallback but log the critical issue
     return this.lastProcessedBlock;
   }
 
@@ -529,43 +530,48 @@ export class SyncService {
       const events = eventsResponse?.events || [];
 
       // Transform Stellar events into our format
-      return events.map((event: unknown) => {
-        const stellarEvent = event as {
-          ledger: number;
-          ledgerClosedAt: string;
-          id: string;
-          topic?: string[];
-          value?: Record<string, unknown>;
-          txHash: string;
-          contractId: string;
-        };
-
-        return {
-          id: `${stellarEvent.ledger}-${stellarEvent.ledgerClosedAt}-${stellarEvent.id}`,
-          type: this.mapStellarEventType(stellarEvent.topic?.[0] || 'unknown'),
-          blockNumber: stellarEvent.ledger,
-          timestamp: new Date(stellarEvent.ledgerClosedAt),
-          data: this.parseStellarEventData(stellarEvent),
-          txHash: stellarEvent.txHash,
-          contractId: stellarEvent.contractId,
-        };
-      });
+      const transformedEvents = await Promise.all(
+        events.map(async (event: unknown) => {
+          const stellarEvent = event as {
+            ledger: number;
+            ledgerClosedAt: string;
+            id: string;
+            topic?: string[];
+            value?: Record<string, unknown>;
+            txHash: string;
+            contractId: string;
+          };
+
+          return {
+            id: `${stellarEvent.ledger}-${stellarEvent.ledgerClosedAt}-${stellarEvent.id}`,
+            type: this.mapStellarEventType(stellarEvent.topic?.[0] || 'unknown'),
+            blockNumber: stellarEvent.ledger,
+            timestamp: new Date(stellarEvent.ledgerClosedAt),
+            data: await this.parseStellarEventData(stellarEvent),
+            txHash: stellarEvent.txHash,
+            contractId: stellarEvent.contractId,
+          };
+        })
+      );
+
+      return transformedEvents;
     } catch (error) {
-      console.error('Failed to get contract events:', error);
-
-      // Log the error but don't throw to prevent sync service from stopping
-      await supabase.from('sync_logs').insert({
-        operation: 'get_contract_events',
-        status: 'error',
-        message: 'Failed to query blockchain events',
-        error_details: {
-          error: error instanceof Error ? error.message : 'Unknown error',
-          from_block: fromBlock,
-          to_block: toBlock,
-        },
+      // Log the error using loggingService
+      const errorLog = await loggingService.logBlockchainOperation('getContractEvents', {
+        fromBlock,
+        toBlock,
+      });
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Failed to query blockchain events',
       });
 
-      return [];
+      // Re-throw as SyncError for proper error handling
+      throw new SyncError('Failed to get contract events', 'GET_EVENTS_FAIL', {
+        error,
+        fromBlock,
+        toBlock,
+      });
     }
   }
 
@@ -590,9 +596,9 @@ export class SyncService {
   /**
    * Parse Stellar event data into our format
    */
-  private parseStellarEventData(event: {
+  private async parseStellarEventData(event: {
     value?: Record<string, unknown>;
-  }): BlockchainEventData {
+  }): Promise<BlockchainEventData> {
     try {
       // Parse event data based on contract event structure
       const eventData = event.value || {};
@@ -609,60 +615,192 @@ export class SyncService {
         guests: eventData.guests ? Number(eventData.guests) : undefined,
       };
     } catch (error) {
-      console.error('Failed to parse event data:', error);
+      // Log parsing error properly
+      // This is intentionally not re-thrown as parsing failures shouldn't stop sync
+      // Using async logging but handling failures gracefully
+      try {
+        const errorLog = await loggingService.logBlockchainOperation('parseStellarEventData', {
+          event: event.value,
+        });
+        await loggingService.logBlockchainError(errorLog, {
+          error,
+          context: 'Failed to parse event data - returning empty object',
+        });
+      } catch (loggingError) {
+        // Log to console as fallback if logging service fails
+        console.error('Failed to log parseStellarEventData error:', loggingError);
+        console.error('Original parsing error:', error);
+      }
       return {};
     }
   }
 
   /**
-   * Process a single blockchain event
+   * Check if event has already been processed (duplicate check)
+   */
+  private async isEventAlreadyProcessed(eventId: string): Promise<boolean> {
+    try {
+      const { data, error } = await supabase
+        .from('sync_events')
+        .select('id, processed')
+        .eq('event_id', eventId)
+        .single();
+
+      if (error && error.code !== 'PGRST116') {
+        // PGRST116 is "not found" which is expected for new events
+        // Other errors should be logged but not block processing
+        const errorLog = await loggingService.logBlockchainOperation('isEventAlreadyProcessed', {
+          eventId,
+        });
+        await loggingService.logBlockchainError(errorLog, {
+          error,
+          context: 'Error checking for duplicate event',
+        });
+      }
+
+      return data !== null && data !== undefined;
+    } catch (error) {
+      // Log error but don't block processing - let the atomic function handle duplicates
+      const errorLog = await loggingService.logBlockchainOperation('isEventAlreadyProcessed', {
+        eventId,
+      });
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Exception checking for duplicate event',
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Determine the new status for an event type
+   */
+  private getStatusForEventType(
+    eventType: string,
+    eventData: BlockchainEventData
+  ): string | undefined {
+    switch (eventType) {
+      case 'booking_cancelled':
+        return 'cancelled';
+      case 'payment_confirmed':
+        return 'confirmed';
+      case 'escrow_created':
+        return 'pending';
+      case 'escrow_released':
+        return 'completed';
+      case 'booking_updated':
+      case 'booking_created':
+        return eventData.status ? this.mapBlockchainStatus(eventData.status) : undefined;
+      default:
+        return undefined;
+    }
+  }
+
+  /**
+   * Process a single blockchain event atomically
    */
   private async processEvent(event: Record<string, unknown>): Promise<void> {
+    const eventId = event.id as string;
+    const eventType = event.type as string;
+    const eventData = event.data as BlockchainEventData;
+    const txHash = event.txHash as string | undefined;
+
     try {
-      const logId = await loggingService.logBlockchainOperation('processEvent', { event });
+      const logId = await loggingService.logBlockchainOperation('processEvent', {
+        eventId,
+        eventType,
+        txHash,
+      });
 
-      // Store event in database for tracking
-      await this.storeSyncEvent(event);
+      // Validate transaction ID before processing (explicit duplicate check)
+      const isDuplicate = await this.isEventAlreadyProcessed(eventId);
+      if (isDuplicate) {
+        await loggingService.logBlockchainSuccess(logId, {
+          eventId,
+          skipped: true,
+          reason: 'duplicate_event_detected_before_processing',
+        });
+        return;
+      }
 
-      // Process based on event type
-      switch (event.type as string) {
+      // Extract event metadata
+      const bookingId = eventData.escrow_id || (event.bookingId as string) || null;
+      const propertyId = eventData.property_id || (event.propertyId as string) || null;
+      const userId = eventData.user_id || (event.userId as string) || 'unknown';
+      const newStatus = this.getStatusForEventType(eventType, eventData);
+
+      // Process event atomically (insert, update status if applicable, mark as processed)
+      const result = await this.processEventAtomic(
+        eventId,
+        eventType,
+        bookingId,
+        propertyId,
+        userId,
+        eventData as unknown as Record<string, unknown>,
+        newStatus
+      );
+
+      // Handle duplicate event (detected during atomic processing)
+      if (result.error === 'DUPLICATE_EVENT') {
+        await loggingService.logBlockchainSuccess(logId, {
+          eventId,
+          skipped: true,
+          reason: 'duplicate_event_detected_during_atomic_processing',
+        });
+        return;
+      }
+
+      // For events that require additional processing beyond status updates
+      // (e.g., creating bookings, logging), handle them after atomic processing
+      // These operations are idempotent or handle their own errors gracefully
+      switch (eventType) {
         case 'booking_created':
+          // Booking creation is handled by handleBookingCreated which checks for existing bookings
           await this.handleBookingCreated(event);
           break;
         case 'booking_updated':
+          // Enhanced sync with booking service
           await this.handleBookingUpdated(event);
           break;
-        case 'booking_cancelled':
-          await this.handleBookingCancelled(event);
-          break;
-        case 'payment_confirmed':
-          await this.handlePaymentConfirmed(event);
-          break;
         case 'property_created':
-          await this.handlePropertyCreated(event);
-          break;
         case 'property_updated':
-          await this.handlePropertyUpdated(event);
+          // These only do logging, which is safe to do after atomic processing
+          if (eventType === 'property_created') {
+            await this.handlePropertyCreated(event);
+          } else {
+            await this.handlePropertyUpdated(event);
+          }
           break;
         case 'escrow_created':
-          await this.handleEscrowCreated(event);
-          break;
         case 'escrow_released':
-          await this.handleEscrowReleased(event);
+          // These do additional logging after status update
+          if (eventType === 'escrow_created') {
+            await this.handleEscrowCreated(event);
+          } else {
+            await this.handleEscrowReleased(event);
+          }
           break;
+        // booking_cancelled, payment_confirmed are fully handled by processEventAtomic
         default:
-          console.warn(`Unknown event type: ${event.type as string}`);
+          if (eventType !== 'unknown') {
+            console.warn(`Unknown event type: ${eventType}`);
+          }
       }
 
-      // Mark event as processed
-      await this.markEventProcessed(event.id as string);
-
       await loggingService.logBlockchainSuccess(logId, {
-        eventId: event.id as string,
+        eventId,
+        syncEventId: result.syncEventId,
       });
     } catch (error) {
-      console.error(`Error processing event ${event.id as string}:`, error);
-      await this.markEventFailed(event.id as string, error as Error);
+      const errorLog = await loggingService.logBlockchainOperation('processEvent', {
+        eventId,
+        eventType,
+      });
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Failed to process blockchain event',
+      });
+      await this.markEventFailed(eventId, error as Error);
       throw error;
     }
   }
@@ -717,48 +855,62 @@ export class SyncService {
         await bookingService.syncBookingFromBlockchain(
           eventData.escrow_id,
           this.mapBlockchainStatus(eventData.status),
-          eventData
+          eventData as unknown as Record<string, unknown>
         );
       } catch (error) {
-        console.error('Failed to sync booking from blockchain event:', error);
+        // Log and use fallback to direct database update
+        const errorLog = await loggingService.logBlockchainOperation('handleBookingUpdated', {
+          escrowId: eventData.escrow_id,
+          status: eventData.status,
+        });
+        await loggingService.logBlockchainError(errorLog, {
+          error,
+          context: 'Failed to sync booking from blockchain event - using fallback',
+        });
         // Fallback to direct database update
-        await supabase
-          .from('bookings')
-          .update({
-            status: this.mapBlockchainStatus(eventData.status),
-            updated_at: new Date().toISOString(),
-          })
-          .eq('escrow_address', eventData.escrow_id);
+        try {
+          await supabase
+            .from('bookings')
+            .update({
+              status: this.mapBlockchainStatus(eventData.status),
+              updated_at: new Date().toISOString(),
+            })
+            .eq('escrow_address', eventData.escrow_id);
+        } catch (fallbackError) {
+          // Log fallback failure but don't rethrow - event was already processed atomically
+          const fallbackErrorLog = await loggingService.logBlockchainOperation(
+            'handleBookingUpdated_fallback',
+            {
+              escrowId: eventData.escrow_id,
+            }
+          );
+          await loggingService.logBlockchainError(fallbackErrorLog, {
+            error: fallbackError,
+            context: 'Fallback database update also failed',
+          });
+        }
       }
     }
   }
 
   /**
    * Handle booking cancellation event
+   * Note: Status update is handled atomically by processEventAtomic
+   * This handler is kept for potential future additional processing
    */
-  private async handleBookingCancelled(event: Record<string, unknown>): Promise<void> {
-    const eventData = event.data as BlockchainEventData;
-    await supabase
-      .from('bookings')
-      .update({
-        status: 'cancelled',
-        updated_at: new Date().toISOString(),
-      })
-      .eq('escrow_address', eventData.escrow_id || '');
+  private async handleBookingCancelled(_event: Record<string, unknown>): Promise<void> {
+    // Status update is handled atomically by processEventAtomic
+    // No additional processing needed at this time
   }
 
   /**
    * Handle payment confirmation event
+   * Note: Status update is handled atomically by processEventAtomic
+   * This handler is kept for potential future additional processing
    */
-  private async handlePaymentConfirmed(event: Record<string, unknown>): Promise<void> {
-    const eventData = event.data as BlockchainEventData;
-    await supabase
-      .from('bookings')
-      .update({
-        status: 'confirmed',
-        updated_at: new Date().toISOString(),
-      })
-      .eq('escrow_address', eventData.escrow_id || '');
+  private async handlePaymentConfirmed(_event: Record<string, unknown>): Promise<void> {
+    // Status update is handled atomically by processEventAtomic
+    // No additional processing needed at this time
   }
 
   /**
@@ -807,20 +959,13 @@ export class SyncService {
 
   /**
    * Handle escrow creation event
+   * Note: Status update is handled atomically by processEventAtomic
+   * This handler only performs additional logging
    */
   private async handleEscrowCreated(event: Record<string, unknown>): Promise<void> {
     const eventData = event.data as BlockchainEventData;
 
-    // Update booking with escrow creation confirmation
-    await supabase
-      .from('bookings')
-      .update({
-        status: 'pending',
-        updated_at: new Date().toISOString(),
-      })
-      .eq('escrow_address', eventData.escrow_id || '');
-
-    // Log the event
+    // Log the event (status update already handled atomically)
     await supabase.from('sync_logs').insert({
       operation: 'handle_escrow_created',
       status: 'success',
@@ -836,20 +981,13 @@ export class SyncService {
 
   /**
    * Handle escrow release event
+   * Note: Status update is handled atomically by processEventAtomic
+   * This handler only performs additional logging
    */
   private async handleEscrowReleased(event: Record<string, unknown>): Promise<void> {
     const eventData = event.data as BlockchainEventData;
 
-    // Update booking to completed status when escrow is released
-    await supabase
-      .from('bookings')
-      .update({
-        status: 'completed',
-        updated_at: new Date().toISOString(),
-      })
-      .eq('escrow_address', eventData.escrow_id || '');
-
-    // Log the event
+    // Log the event (status update already handled atomically)
     await supabase.from('sync_logs').insert({
       operation: 'handle_escrow_released',
       status: 'success',
@@ -875,6 +1013,63 @@ export class SyncService {
     return statusMap[blockchainStatus] || 'pending';
   }
 
+  /**
+   * Process sync event atomically using PostgreSQL RPC function
+   * This ensures event logging, status updates, and marking as processed
+   * all happen in a single transaction to prevent inconsistent states.
+   */
+  async processEventAtomic(
+    eventId: string,
+    eventType: string,
+    bookingId: string | null,
+    propertyId: string | null,
+    userId: string,
+    eventData: Record<string, unknown>,
+    newStatus?: string
+  ): Promise<{ success: boolean; syncEventId?: string; error?: string }> {
+    const log = await loggingService.logBlockchainOperation('processEventAtomic', {
+      eventId,
+      eventType,
+      bookingId,
+      newStatus,
+    });
+
+    try {
+      const { data, error } = await supabase.rpc('process_sync_event_atomic', {
+        p_event_id: eventId,
+        p_event_type: eventType,
+        p_booking_id: bookingId,
+        p_property_id: propertyId,
+        p_user_id: userId,
+        p_event_data: eventData,
+        p_new_status: newStatus || null,
+      });
+
+      if (error) {
+        await loggingService.logBlockchainError(log, { error, context: 'RPC call failed' });
+        throw new SyncError('Failed to process event atomically', 'ATOMIC_PROCESS_FAIL', error);
+      }
+
+      if (!data.success) {
+        if (data.error === 'DUPLICATE_EVENT') {
+          // Duplicate events are not errors, just skip them
+          await loggingService.logBlockchainSuccess(log, { skipped: true, reason: 'duplicate' });
+          return { success: true, error: 'DUPLICATE_EVENT' };
+        }
+        throw new SyncError(`Atomic processing failed: ${data.error}`, data.error, data);
+      }
+
+      await loggingService.logBlockchainSuccess(log, { syncEventId: data.sync_event_id });
+      return { success: true, syncEventId: data.sync_event_id };
+    } catch (error) {
+      if (error instanceof SyncError) {
+        throw error;
+      }
+      await loggingService.logBlockchainError(log, { error, context: 'processEventAtomic' });
+      throw new SyncError('Failed to process event atomically', 'ATOMIC_PROCESS_FAIL', error);
+    }
+  }
+
   /**
    * Store sync event in database
    */
@@ -923,17 +1118,34 @@ export class SyncService {
    * Update sync state in database
    */
   private async updateSyncState(): Promise<void> {
-    const { error } = await supabase.from('sync_state').upsert({
-      id: 1, // Single row for sync state
-      last_processed_block: this.lastProcessedBlock,
-      total_events_processed: this.totalEventsProcessed,
-      failed_events: this.failedEvents,
-      last_sync_time: this.lastSyncTime?.toISOString(),
-      updated_at: new Date().toISOString(),
-    });
+    try {
+      const { error } = await supabase.from('sync_state').upsert({
+        id: 1, // Single row for sync state
+        last_processed_block: this.lastProcessedBlock,
+        total_events_processed: this.totalEventsProcessed,
+        failed_events: this.failedEvents,
+        last_sync_time: this.lastSyncTime?.toISOString(),
+        updated_at: new Date().toISOString(),
+      });
 
-    if (error) {
-      console.error('Failed to update sync state:', error);
+      if (error) {
+        const errorLog = await loggingService.logBlockchainOperation('updateSyncState', {
+          lastProcessedBlock: this.lastProcessedBlock,
+          totalEventsProcessed: this.totalEventsProcessed,
+        });
+        await loggingService.logBlockchainError(errorLog, {
+          error,
+          context: 'Failed to update sync state in database',
+        });
+        // Don't rethrow - sync can continue even if state update fails
+      }
+    } catch (error) {
+      const errorLog = await loggingService.logBlockchainOperation('updateSyncState', {});
+      await loggingService.logBlockchainError(errorLog, {
+        error,
+        context: 'Exception updating sync state',
+      });
+      // Don't rethrow - sync can continue even if state update fails
     }
   }
 
@@ -972,3 +1184,4 @@ export class SyncService {
 
 // Export singleton instance
 export const syncService = new SyncService();
+
diff --git a/apps/backend/src/services/wallet-auth.service.ts b/apps/backend/src/services/wallet-auth.service.ts
deleted file mode 100644
index 93991b8b..00000000
--- a/apps/backend/src/services/wallet-auth.service.ts
+++ /dev/null
@@ -1,211 +0,0 @@
-import { Networks, StrKey, Transaction } from '@stellar/stellar-sdk';
-import jwt from 'jsonwebtoken';
-import { supabase } from '../config/supabase';
-import type { WalletAuthResponse, WalletLoginRequest } from '../types/wallet-auth.types';
-import {
-  InvalidChallengeError,
-  InvalidPublicKeyError,
-  SignatureVerificationError,
-} from '../types/wallet-error-types';
-import { getValidChallenge, removeChallenge } from './wallet-challenge.service';
-
-//===================
-// Verify the signed transaction contains the correct challenge and is signed by the correct key
-//===================
-async function verifySignedTransaction(
-  publicKey: string,
-  challenge: string,
-  signedTransactionXDR: string
-): Promise<boolean> {
-  try {
-    const transaction = new Transaction(
-      signedTransactionXDR,
-      process.env.NODE_ENV === 'production' ? Networks.PUBLIC : Networks.TESTNET
-    );
-    if (transaction.signatures.length === 0) {
-      console.error('No signatures found in transaction');
-      return false;
-    }
-    const sourceAccount = transaction.source;
-    if (sourceAccount !== publicKey) {
-      console.error('Transaction source account mismatch');
-      return false;
-    }
-    // Verify the transaction memo contains our challenge
-    const memo = transaction.memo;
-    if (!memo || memo.type !== 'text') {
-      console.error('Invalid memo type:', memo?.type);
-      return false;
-    }
-
-    let memoValue: string;
-    if (Buffer.isBuffer(memo.value)) {
-      memoValue = memo.value.toString('utf8');
-    } else {
-      memoValue = memo.value as string;
-    }
-
-    if (memoValue !== challenge) {
-      console.error('Memo mismatch!');
-      console.error('   Expected:', challenge);
-      return false;
-    }
-    const transactionHash = transaction.hash();
-    const signature = transaction.signatures[0];
-
-    const { Keypair } = await import('@stellar/stellar-sdk');
-    const keypair = Keypair.fromPublicKey(publicKey);
-
-    // Verify the signature
-    const isValid = keypair.verify(transactionHash, signature.signature());
-
-    if (!isValid) {
-      console.error('Signature verification failed');
-    } else {
-      console.log('Signature verification successful');
-    }
-
-    return isValid;
-  } catch (error) {
-    console.error('Transaction verification error:', error);
-    return false;
-  }
-}
-
-//===================
-// Get or create wallet user
-//===================
-async function getOrCreateWalletUser(publicKey: string) {
-  console.log('Getting or creating wallet user for:', `${publicKey.substring(0, 10)}...`);
-
-  const { data: existingUser, error: fetchError } = await supabase
-    .from('wallet_users')
-    .select('*')
-    .eq('public_key', publicKey)
-    .single();
-
-  if (existingUser && !fetchError) {
-    await supabase
-      .from('wallet_users')
-      .update({ updated_at: new Date().toISOString() })
-      .eq('id', existingUser.id);
-
-    return existingUser;
-  }
-
-  const { data: newUser, error: createError } = await supabase
-    .from('wallet_users')
-    .insert({
-      public_key: publicKey,
-    })
-    .select()
-    .single();
-
-  if (createError || !newUser) {
-    console.error('Error creating wallet user:', createError);
-    throw new Error('Failed to create wallet user');
-  }
-
-  console.log('New user created:', newUser.id);
-
-  const { error: profileError } = await supabase.from('profiles').insert({
-    user_id: newUser.id,
-    name: 'Wallet User',
-    verification_status: 'unverified',
-    last_active: new Date().toISOString(),
-  });
-
-  if (profileError) {
-    console.error('Warning: Failed to create profile:', profileError.message || profileError);
-  } else {
-    console.log('Profile created for user');
-  }
-
-  return newUser;
-}
-
-//===================
-// Get user profile
-//===================
-async function getUserProfile(userId: string) {
-  const { data: profile } = await supabase
-    .from('profiles')
-    .select('*')
-    .eq('user_id', userId)
-    .single();
-
-  return profile || undefined;
-}
-
-//===================
-// Generate JWT token
-//===================
-function generateJWT(userId: string, publicKey: string): string {
-  if (!process.env.JWT_SECRET) {
-    throw new Error('JWT_SECRET environment variable is required');
-  }
-
-  return jwt.sign(
-    {
-      userId,
-      publicKey,
-      type: 'wallet',
-    },
-    process.env.JWT_SECRET,
-    {
-      expiresIn: '7d',
-    }
-  );
-}
-
-//===================
-// Verify wallet signature and authenticate user
-//===================
-export async function authenticateWallet(input: WalletLoginRequest): Promise<WalletAuthResponse> {
-  const { publicKey, signedTransaction, challenge } = input;
-  const userKey = `${publicKey.substring(0, 10)}...`;
-
-  console.log(`Starting wallet authentication for ${userKey}`);
-  console.log(`Challenge: ${challenge}`);
-
-  if (!StrKey.isValidEd25519PublicKey(publicKey)) {
-    console.error(`Invalid public key format for ${userKey}`);
-    throw new InvalidPublicKeyError('Invalid public key format');
-  }
-  console.log(`Public key format is valid for ${userKey}`);
-
-  console.log(`Validating challenge for ${userKey}...`);
-  const storedChallenge = await getValidChallenge(publicKey, challenge);
-  if (!storedChallenge) {
-    console.error(`Invalid or expired challenge for ${userKey}`);
-    throw new InvalidChallengeError('Invalid or expired challenge');
-  }
-  console.log(`Challenge is valid for ${userKey}`);
-  console.log(`Verifying signed transaction for ${userKey}...`);
-  const isValidTransaction = await verifySignedTransaction(publicKey, challenge, signedTransaction);
-  if (!isValidTransaction) {
-    console.error(`Transaction verification failed for ${userKey}`);
-    throw new SignatureVerificationError('Invalid signed transaction');
-  }
-  console.log(`Transaction verification successful for ${userKey}`);
-
-  console.log(`Removing used challenge for ${userKey}...`);
-  await removeChallenge(storedChallenge.id);
-
-  console.log(`Getting or creating wallet user for ${userKey}...`);
-  const walletUser = await getOrCreateWalletUser(publicKey);
-
-  console.log(`Generating JWT token for ${userKey}...`);
-  const token = generateJWT(walletUser.id, publicKey);
-
-  const profile = await getUserProfile(walletUser.id);
-  console.log(`Wallet authentication completed successfully for ${userKey}!`);
-  return {
-    token,
-    user: {
-      id: walletUser.id,
-      publicKey,
-      profile,
-    },
-  };
-}
diff --git a/apps/backend/src/services/wallet-challenge.service.ts b/apps/backend/src/services/wallet-challenge.service.ts
deleted file mode 100644
index 4ee5363c..00000000
--- a/apps/backend/src/services/wallet-challenge.service.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { supabase } from '../config/supabase';
-import type { Challenge, ChallengeResponse } from '../types/wallet-auth.types';
-
-//===================
-// Generate a unique challenge for a given public key
-//===================
-export async function generateChallenge(publicKey: string): Promise<ChallengeResponse> {
-  const CHALLENGE_EXPIRY_MINUTES = 5;
-
-  // Check if there's already a valid challenge for this public key
-  const { data: existingChallenge, error: fetchError } = await supabase
-    .from('wallet_challenges')
-    .select('*')
-    .eq('public_key', publicKey)
-    .gt('expires_at', new Date().toISOString())
-    .single();
-
-  if (existingChallenge && !fetchError) {
-    console.log(`Reusing existing challenge for ${publicKey.substring(0, 10)}...`);
-    return {
-      challenge: existingChallenge.challenge,
-      expiresAt: existingChallenge.expires_at,
-    };
-  }
-
-  const challenge = randomBytes(12).toString('hex');
-  const expiresAt = new Date(Date.now() + CHALLENGE_EXPIRY_MINUTES * 60 * 1000);
-
-  await cleanupExpiredChallenges(publicKey);
-
-  const { error } = await supabase.from('wallet_challenges').insert({
-    public_key: publicKey,
-    challenge,
-    expires_at: expiresAt.toISOString(),
-  });
-
-  if (error) {
-    console.error('Error storing challenge:', error);
-    throw new Error('Failed to generate challenge');
-  }
-
-  console.log(`Generated new challenge for ${publicKey.substring(0, 10)}...`);
-  return {
-    challenge,
-    expiresAt: expiresAt.toISOString(),
-  };
-}
-
-//===================
-// Retrieve and validate a challenge for a given public key
-//===================
-export async function getValidChallenge(
-  publicKey: string,
-  challengeValue: string
-): Promise<Challenge | null> {
-  const { data, error } = await supabase
-    .from('wallet_challenges')
-    .select('*')
-    .eq('public_key', publicKey)
-    .eq('challenge', challengeValue)
-    .gt('expires_at', new Date().toISOString())
-    .single();
-
-  if (error || !data) {
-    return null;
-  }
-
-  return data;
-}
-
-//===================
-// Remove a used challenge
-//===================
-export async function removeChallenge(challengeId: string): Promise<void> {
-  const { error } = await supabase.from('wallet_challenges').delete().eq('id', challengeId);
-
-  if (error) {
-    console.error('Error removing challenge:', error);
-  }
-}
-
-//===================
-// Clean up expired challenges for a public key
-//===================
-async function cleanupExpiredChallenges(publicKey?: string): Promise<void> {
-  let query = supabase
-    .from('wallet_challenges')
-    .delete()
-    .lt('expires_at', new Date().toISOString());
-
-  if (publicKey) {
-    query = query.eq('public_key', publicKey);
-  }
-
-  const { error } = await query;
-
-  if (error) {
-    console.error('Error cleaning up expired challenges:', error);
-  }
-}
-
-//===================
-// Periodic cleanup of all expired challenges
-//===================
-// export async function cleanupAllExpiredChallenges(): Promise<void> {
-//   await cleanupExpiredChallenges();
-// }
-export async function cleanupAllExpiredChallenges(): Promise<void> {
-  try {
-    const { data: expiredChallenges, error: fetchError } = await supabase
-      .from('wallet_challenges')
-      .select('id')
-      .lt('expires_at', new Date().toISOString());
-
-    if (fetchError) {
-      console.error('Error fetching expired challenges:', fetchError);
-      return;
-    }
-
-    if (!expiredChallenges || expiredChallenges.length === 0) {
-      console.log('No expired challenges to cleanup');
-      return;
-    }
-
-    const { error: deleteError } = await supabase
-      .from('wallet_challenges')
-      .delete()
-      .lt('expires_at', new Date().toISOString());
-
-    if (deleteError) {
-      console.error('Error cleaning up expired challenges:', deleteError);
-    } else {
-      console.log(`🗑️ Cleaned up ${expiredChallenges.length} expired challenges`);
-    }
-  } catch (error) {
-    console.error('Error during cleanup:', error);
-  }
-}
diff --git a/apps/backend/src/types/errors.ts b/apps/backend/src/types/errors.ts
new file mode 100644
index 00000000..56d2b355
--- /dev/null
+++ b/apps/backend/src/types/errors.ts
@@ -0,0 +1,49 @@
+/**
+ * Custom Error Classes for StellarRent Backend
+ *
+ * These error classes provide structured error handling for different
+ * domains within the application, enabling better error tracking,
+ * logging, and API responses.
+ */
+
+/**
+ * Error class for escrow-related operations
+ */
+export class EscrowError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public details?: unknown
+  ) {
+    super(message);
+    this.name = 'EscrowError';
+  }
+}
+
+/**
+ * Error class for blockchain synchronization operations
+ */
+export class SyncError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public details?: unknown
+  ) {
+    super(message);
+    this.name = 'SyncError';
+  }
+}
+
+/**
+ * Error class for cache operations
+ */
+export class CacheError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public details?: unknown
+  ) {
+    super(message);
+    this.name = 'CacheError';
+  }
+}
diff --git a/apps/backend/src/types/wallet-auth.types.ts b/apps/backend/src/types/wallet-auth.types.ts
deleted file mode 100644
index 19f76cd6..00000000
--- a/apps/backend/src/types/wallet-auth.types.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { z } from 'zod';
-
-// Challenge request schema
-export const challengeRequestSchema = z.object({
-  publicKey: z.string().min(1, 'Public key is required'),
-});
-
-// Wallet login schema
-export const walletLoginSchema = z.object({
-  publicKey: z.string().min(1, 'Public key is required'),
-  signedTransaction: z.string().min(1, 'Signed transaction is required'),
-  challenge: z.string().min(1, 'Challenge is required'),
-});
-
-// Types
-export type ChallengeRequest = z.infer<typeof challengeRequestSchema>;
-export type WalletLoginRequest = z.infer<typeof walletLoginSchema>;
-
-export interface Challenge {
-  id: string;
-  public_key: string;
-  challenge: string;
-  expires_at: string;
-  created_at: string;
-}
-
-export interface WalletAuthResponse {
-  token: string;
-  user: {
-    id: string;
-    publicKey: string;
-    profile?: {
-      name?: string;
-      avatar_url?: string;
-      phone?: string;
-      address?: string;
-      preferences?: Record<string, null>;
-      social_links?: Record<string, null>;
-      verification_status: string;
-      last_active: string;
-    };
-  };
-}
-
-export interface ChallengeResponse {
-  challenge: string;
-  expiresAt: string;
-}
diff --git a/apps/backend/src/validators/wallet-auth.validator.ts b/apps/backend/src/validators/wallet-auth.validator.ts
deleted file mode 100644
index 568fcd19..00000000
--- a/apps/backend/src/validators/wallet-auth.validator.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import type { NextFunction, Request, Response } from 'express';
-import { z } from 'zod';
-import { challengeRequestSchema, walletLoginSchema } from '../types/wallet-auth.types';
-
-//===================
-// Validate challenge request
-//===================
-export const validateChallengeRequest = (req: Request, res: Response, next: NextFunction) => {
-  try {
-    challengeRequestSchema.parse(req.body);
-    next();
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return res.status(400).json({
-        error: 'Invalid challenge request data',
-        details: error.errors,
-      });
-    }
-    next(error);
-  }
-};
-
-//===================
-// Validate wallet login request
-//===================
-export const validateWalletLogin = (req: Request, res: Response, next: NextFunction) => {
-  try {
-    walletLoginSchema.parse(req.body);
-    next();
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return res.status(400).json({
-        error: 'Invalid wallet login data',
-        details: error.errors,
-      });
-    }
-    next(error);
-  }
-};
diff --git a/apps/backend/tests/utils/booking-test.utils.ts b/apps/backend/tests/utils/booking-test.utils.ts
index 7fc25158..a901c269 100644
--- a/apps/backend/tests/utils/booking-test.utils.ts
+++ b/apps/backend/tests/utils/booking-test.utils.ts
@@ -19,7 +19,6 @@ mock.module('../../src/config/supabase', () => ({
       select: mock(() => ({
         eq: mock(() => ({
           single: mock(() => Promise.resolve({ data: null, error: null })),
-<<<<<<< HEAD
           then: mock((callback: any) => callback({ data: [], error: null })),
         })),
         in: mock(() => Promise.resolve({ data: [], error: null })),
@@ -42,27 +41,13 @@ mock.module('../../src/config/supabase', () => ({
         eq: mock(() => Promise.resolve({ data: [], error: null })),
         in: mock(() => Promise.resolve({ data: [], error: null })),
         then: mock((callback: any) => callback({ data: [], error: null })),
-=======
-        })),
-      })),
-      insert: mock(() => ({
-        select: mock(() => Promise.resolve({ data: [], error: null })),
-      })),
-      update: mock(() => ({
-        eq: mock(() => Promise.resolve({ data: [], error: null })),
-      })),
-      delete: mock(() => ({
-        eq: mock(() => Promise.resolve({ data: [], error: null })),
->>>>>>> f4a72f1 (feat: connect smart contracts to backend APIs)
       })),
       upsert: mock(() => ({
         eq: mock(() => Promise.resolve({ data: [], error: null })),
       })),
-<<<<<<< HEAD
       then: mock((callback: any) => callback({ data: [], error: null })),
-=======
->>>>>>> f4a72f1 (feat: connect smart contracts to backend APIs)
     })),
+    rpc: mock(() => Promise.resolve({ data: { success: true }, error: null })),
     auth: {
       getUser: mock(() =>
         Promise.resolve({
diff --git a/apps/web/.env.example b/apps/web/.env.example
index 4ae2ec1b..260f0128 100644
--- a/apps/web/.env.example
+++ b/apps/web/.env.example
@@ -1,4 +1,14 @@
-NEXT_PUBLIC_STELLAR_NETWORK=
+# Stellar Network Configuration
+NEXT_PUBLIC_STELLAR_NETWORK=testnet
 NEXT_PUBLIC_USDC_ISSUER_TESTNET=
 NEXT_PUBLIC_USDC_ISSUER_MAINNET=
-NEXT_PUBLIC_API_URL=
\ No newline at end of file
+
+# API Configuration
+NEXT_PUBLIC_API_URL=http://localhost:3001/api
+
+# Stellar Social Login SDK Configuration
+# Get your Google Client ID from: https://console.cloud.google.com/apis/credentials
+NEXT_PUBLIC_GOOGLE_CLIENT_ID=your_google_client_id_here
+
+# Soroban Contract ID for Social Wallet
+NEXT_PUBLIC_CONTRACT_ID=CALZGCSB3P3WEBLW3QTF5Y4WEALEVTYUYBC7KBGQ266GDINT7U4E74KW
diff --git a/apps/web/package.json b/apps/web/package.json
index e2af0336..8ad2fd90 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -12,6 +12,7 @@
     "test:e2e:headed": "playwright test --headed"
   },
   "dependencies": {
+    "stellar-social-sdk": "file:./stellar-social-sdk",
     "@hookform/resolvers": "^3.3.4",
     "@radix-ui/react-dialog": "^1.1.14",
     "@radix-ui/react-dropdown-menu": "^2.1.12",
diff --git a/apps/web/src/app/dashboard/tenant-dashboard/page.tsx b/apps/web/src/app/dashboard/tenant-dashboard/page.tsx
index 0c8b32f9..9a0e2cd4 100644
--- a/apps/web/src/app/dashboard/tenant-dashboard/page.tsx
+++ b/apps/web/src/app/dashboard/tenant-dashboard/page.tsx
@@ -13,6 +13,13 @@ import {
   DollarSign,
   Download,
   Edit3,
+  Eye,
+  Filter,
+  Home,
+  Info,
+  LogOut,
+  MapPin,
+  MessageSquare,
   PieChart,
   Settings,
   Star,
@@ -20,7 +27,10 @@ import {
   Wallet,
 } from 'lucide-react';
 import Image from 'next/image';
-import { useState } from 'react';
+import { useRouter } from 'next/navigation';
+import type React from 'react';
+import { useEffect, useState } from 'react';
+import { useAuth } from '~/hooks/auth/use-auth';
 
 interface Booking {
   id: string;
@@ -165,6 +175,8 @@ const mockTransactions = [
 ];
 
 const TenantDashboard = () => {
+  const router = useRouter();
+  const { logout } = useAuth();
   const [activeTab, setActiveTab] = useState('bookings');
   const [bookings, setBookings] = useState(mockBookings);
   const [user, setUser] = useState(mockUser);
@@ -339,6 +351,18 @@ const TenantDashboard = () => {
                     {user.name}
                   </span>
                 </div>
+                <button
+                  type="button"
+                  onClick={() => {
+                    logout();
+                    router.push('/login');
+                  }}
+                  className="flex items-center space-x-1 text-gray-500 dark:text-white hover:text-red-500 dark:hover:text-red-400 transition-colors"
+                  title="Logout"
+                >
+                  <LogOut className="w-5 h-5" />
+                  <span className="text-sm hidden sm:inline">Logout</span>
+                </button>
               </div>
             </div>
           </div>
diff --git a/apps/web/src/app/layout.tsx b/apps/web/src/app/layout.tsx
index 2b6949d2..81018e81 100644
--- a/apps/web/src/app/layout.tsx
+++ b/apps/web/src/app/layout.tsx
@@ -20,6 +20,11 @@ export default function RootLayout({
     <html lang="es" suppressHydrationWarning>
       <head>
         <meta name="color-scheme" content="light dark" />
+        <meta
+          httpEquiv="Permissions-Policy"
+          content="identity-credentials-get=(), publickey-credentials-get=()"
+        />
+        <script src="https://accounts.google.com/gsi/client" async defer />
       </head>
       <body className={`${geist.className} min-h-screen bg-[#0B1320] text-white antialiased`}>
         <div id="theme-portal-root" />
diff --git a/apps/web/src/app/login/page.tsx b/apps/web/src/app/login/page.tsx
index eab8aed3..778cf5b1 100644
--- a/apps/web/src/app/login/page.tsx
+++ b/apps/web/src/app/login/page.tsx
@@ -1,89 +1,152 @@
 'use client';
 
-import WalletAuthButton from '@/components/auth/WalletAuthButton';
-import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { Label } from '@/components/ui/label';
 import { useAuth } from '@/hooks/auth/use-auth';
-import Link from 'next/link';
 import { useRouter, useSearchParams } from 'next/navigation';
-import { useState } from 'react';
+import { useEffect } from 'react';
+import { FreighterFallback } from '~/components/auth/FreighterFallback';
+import { SocialLoginButton } from '~/components/auth/SocialLoginButton';
+
+// Validate redirect URL to prevent open redirect attacks
+function getSafeRedirect(redirectParam: string | null): string {
+  const defaultRedirect = '/dashboard';
+
+  if (!redirectParam) {
+    return defaultRedirect;
+  }
+
+  // Only allow internal paths (must start with / and not //)
+  if (redirectParam.startsWith('/') && !redirectParam.startsWith('//')) {
+    // Additional check: no protocol in the path
+    if (!redirectParam.includes('://')) {
+      return redirectParam;
+    }
+  }
+
+  return defaultRedirect;
+}
 
 export default function LoginPage() {
-  const { login } = useAuth();
+  const { isAuthenticated, isLoading } = useAuth();
   const router = useRouter();
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState('');
   const searchParams = useSearchParams();
-  const redirect = searchParams.get('redirect');
-
-  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
-    e.preventDefault();
-    setError('');
-    setIsLoading(true);
-
-    const formData = new FormData(e.currentTarget);
-    const email = formData.get('email') as string;
-    const password = formData.get('password') as string;
-    const redirectUrl = redirect || '/dashboard';
-
-    try {
-      await login(email, password);
-      router.push(redirectUrl);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to login');
-    } finally {
-      setIsLoading(false);
+  const redirect = getSafeRedirect(searchParams.get('redirect'));
+
+  // Redirect if already authenticated
+  useEffect(() => {
+    if (isAuthenticated && !isLoading) {
+      router.push(redirect);
     }
-  };
+  }, [isAuthenticated, isLoading, router, redirect]);
 
-  return (
-    <div className="container mx-auto px-4 py-8">
-      <div className="max-w-md mx-auto mt-20">
-        <h1 className="text-2xl font-bold mb-6 text-center">Login to StellarRent</h1>
+  // Success handler
+  const handleSuccess = () => {
+    router.push(redirect);
+  };
 
-        <div className="mb-6">
-          <WalletAuthButton />
+  // Show loading while checking auth
+  if (isLoading) {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-[#0B1320]">
+        <div className="flex flex-col items-center gap-4">
+          <div className="animate-spin rounded-full h-12 w-12 border-t-2 border-b-2 border-blue-500" />
+          <p className="text-gray-400">Verifying session...</p>
         </div>
+      </div>
+    );
+  }
 
-        <div className="relative mb-6">
-          <div className="absolute inset-0 flex items-center">
-            <div className="w-full border-t border-gray-300" />
-          </div>
-          <div className="relative flex justify-center text-sm">
-            <span className="px-2 bg-white text-gray-500">Or continue with email</span>
-          </div>
-        </div>
+  // Don't show login if already authenticated
+  if (isAuthenticated) {
+    return null;
+  }
 
-        <form onSubmit={handleSubmit} className="space-y-4">
-          <div>
-            <Label htmlFor="email">Email</Label>
-            <Input id="email" name="email" type="email" required placeholder="Enter your email" />
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-[#0B1320] px-4">
+      <div className="w-full max-w-md">
+        {/* Login card */}
+        <div className="bg-white/5 backdrop-blur-md rounded-2xl p-8 border border-white/10 shadow-xl">
+          {/* Logo and title */}
+          <div className="text-center mb-8">
+            <div className="inline-flex items-center justify-center w-16 h-16 bg-gradient-to-br from-blue-500 to-purple-600 rounded-full mb-4">
+              <svg
+                aria-hidden="true"
+                className="w-8 h-8 text-white"
+                fill="none"
+                viewBox="0 0 24 24"
+                stroke="currentColor"
+              >
+                <path
+                  strokeLinecap="round"
+                  strokeLinejoin="round"
+                  strokeWidth={2}
+                  d="M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6"
+                />
+              </svg>
+            </div>
+            <h1 className="text-2xl font-bold text-white mb-2">Welcome to StellarRent</h1>
+            <p className="text-gray-400">Sign in to access your account</p>
           </div>
 
-          <div>
-            <Label htmlFor="password">Password</Label>
-            <Input
-              id="password"
-              name="password"
-              type="password"
-              required
-              placeholder="Enter your password"
-            />
-          </div>
+          {/* Main button: Google */}
+          <div className="space-y-4">
+            <SocialLoginButton className="w-full" />
+
+            {/* Separator */}
+            <div className="relative my-6">
+              <div className="absolute inset-0 flex items-center">
+                <div className="w-full border-t border-white/10" />
+              </div>
+              <div className="relative flex justify-center text-sm">
+                <span className="px-4 bg-[#0B1320] text-gray-500">or connect your wallet</span>
+              </div>
+            </div>
 
-          {error && <div className="text-red-500 text-sm mt-2">{error}</div>}
+            {/* Fallback: Freighter */}
+            <FreighterFallback onSuccess={handleSuccess} />
+          </div>
 
-          <Button type="submit" className="w-full" disabled={isLoading}>
-            {isLoading ? 'Logging in...' : 'Login'}
-          </Button>
-        </form>
+          {/* Additional info */}
+          <div className="mt-8 p-4 bg-white/5 rounded-lg border border-white/10">
+            <div className="flex items-start gap-3">
+              <div className="flex-shrink-0 mt-0.5">
+                <svg
+                  aria-hidden="true"
+                  className="w-5 h-5 text-blue-400"
+                  fill="none"
+                  viewBox="0 0 24 24"
+                  stroke="currentColor"
+                >
+                  <path
+                    strokeLinecap="round"
+                    strokeLinejoin="round"
+                    strokeWidth={2}
+                    d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
+                  />
+                </svg>
+              </div>
+              <div>
+                <p className="text-sm text-gray-300 font-medium">
+                  Your Stellar wallet is created automatically
+                </p>
+                <p className="text-xs text-gray-500 mt-1">
+                  When you sign in with Google, a unique wallet linked to your account is generated.
+                  You don't need to create or remember any private keys.
+                </p>
+              </div>
+            </div>
+          </div>
+        </div>
 
-        <p className="mt-4 text-center text-sm text-gray-600">
-          {"Don't"} have an account?{' '}
-          <Link href="/register" className="text-blue-600 hover:text-blue-800">
-            Register here
-          </Link>
+        {/* Footer */}
+        <p className="mt-6 text-center text-sm text-gray-500">
+          By continuing, you agree to our{' '}
+          <a href="/terms" className="text-blue-400 hover:text-blue-300">
+            Terms of Service
+          </a>{' '}
+          and{' '}
+          <a href="/privacy" className="text-blue-400 hover:text-blue-300">
+            Privacy Policy
+          </a>
         </p>
       </div>
     </div>
diff --git a/apps/web/src/app/register/page.tsx b/apps/web/src/app/register/page.tsx
index 0036e528..7f024025 100644
--- a/apps/web/src/app/register/page.tsx
+++ b/apps/web/src/app/register/page.tsx
@@ -1,9 +1,28 @@
-import RegisterForm from '../../components/auth/RegisterForm';
+'use client';
 
+import { useRouter } from 'next/navigation';
+import { useEffect } from 'react';
+
+/**
+ * Register page - Redirects to login
+ *
+ * With social login, registration and login are the same process.
+ * This page exists only to maintain compatibility with existing links.
+ */
 export default function RegisterPage() {
+  const router = useRouter();
+
+  useEffect(() => {
+    // Redirect to login since register = login with social auth
+    router.replace('/login');
+  }, [router]);
+
   return (
-    <div className="flex min-h-[calc(100vh-3.5rem)] items-center justify-center px-4 dark:bg-gray-900">
-      <RegisterForm />
+    <div className="min-h-screen flex items-center justify-center bg-[#0B1320]">
+      <div className="flex flex-col items-center gap-4">
+        <div className="animate-spin rounded-full h-12 w-12 border-t-2 border-b-2 border-blue-500" />
+        <p className="text-gray-400">Redirecting to login...</p>
+      </div>
     </div>
   );
 }
diff --git a/apps/web/src/app/tenant-dashboard/page.tsx b/apps/web/src/app/tenant-dashboard/page.tsx
index 05e2cd86..d8678502 100644
--- a/apps/web/src/app/tenant-dashboard/page.tsx
+++ b/apps/web/src/app/tenant-dashboard/page.tsx
@@ -1,11 +1,25 @@
 'use client';
-import { AlertCircle, Check, Home, Loader2, RefreshCw, Settings, User, Wallet } from 'lucide-react';
+import {
+  AlertCircle,
+  Bell,
+  Check,
+  ChevronDown,
+  Home,
+  Loader2,
+  LogOut,
+  RefreshCw,
+  Search,
+  Settings,
+  User,
+  Wallet,
+} from 'lucide-react';
 import Image from 'next/image';
 import { useRouter } from 'next/navigation';
 import { useEffect, useRef, useState } from 'react';
 
 import BookingHistory from '@/components/dashboard/BookingHistory';
 import NotificationSystem from '@/components/dashboard/NotificationSystem';
+import { useAuth } from '@/hooks/auth/use-auth';
 import { useDashboard } from '@/hooks/useDashboard';
 import { transformFromLegacyUser, transformToLegacyBooking, transformToLegacyUser } from '@/types';
 import type {
@@ -19,6 +33,7 @@ import WalletTransactions from './components/wallet-transaction';
 
 const TenantDashboard: React.FC = () => {
   const router = useRouter();
+  const { logout } = useAuth();
   const [activeTab, setActiveTab] = useState<'bookings' | 'profile' | 'wallet'>('bookings');
   const [notifications, setNotifications] = useState<Notification[]>([]);
   const [unreadNotifications, setUnreadNotifications] = useState(0);
@@ -368,6 +383,18 @@ const TenantDashboard: React.FC = () => {
                   </span>
                 </div>
               )}
+              <button
+                type="button"
+                onClick={() => {
+                  logout();
+                  router.push('/login');
+                }}
+                className="flex items-center space-x-1 text-gray-500 dark:text-white hover:text-red-500 dark:hover:text-red-400 transition-colors"
+                title="Logout"
+              >
+                <LogOut className="w-5 h-5" />
+                <span className="text-sm hidden sm:inline">Logout</span>
+              </button>
             </div>
           </div>
         </div>
diff --git a/apps/web/src/components/auth/FreighterFallback.tsx b/apps/web/src/components/auth/FreighterFallback.tsx
new file mode 100644
index 00000000..d96fd605
--- /dev/null
+++ b/apps/web/src/components/auth/FreighterFallback.tsx
@@ -0,0 +1,178 @@
+'use client';
+
+import { isConnected } from '@stellar/freighter-api';
+import { useEffect, useState } from 'react';
+import { useAuth } from '~/hooks/auth/use-auth';
+
+interface FreighterFallbackProps {
+  onSuccess?: () => void;
+  onError?: (error: string) => void;
+  className?: string;
+}
+
+type ConnectionState = 'idle' | 'connecting' | 'success' | 'error';
+
+const FREIGHTER_INSTALL_URL = 'https://www.freighter.app/';
+
+export function FreighterFallback({ onSuccess, onError, className }: FreighterFallbackProps) {
+  const { loginWithFreighter, isLoading } = useAuth();
+  const [state, setState] = useState<ConnectionState>('idle');
+  const [errorMessage, setErrorMessage] = useState<string | null>(null);
+  const [isFreighterInstalled, setIsFreighterInstalled] = useState<boolean | null>(null);
+
+  // Check for Freighter using the official API
+  useEffect(() => {
+    const checkFreighter = async () => {
+      try {
+        const result = await isConnected();
+        // isConnected returns { isConnected: boolean } - use the actual boolean value
+        setIsFreighterInstalled(result.isConnected === true);
+      } catch {
+        // If the API throws, Freighter is likely not installed
+        setIsFreighterInstalled(false);
+      }
+    };
+
+    checkFreighter();
+  }, []);
+
+  const handleConnect = async () => {
+    if (!isFreighterInstalled) {
+      setState('error');
+      setErrorMessage('Freighter is not installed');
+      return;
+    }
+
+    setState('connecting');
+    setErrorMessage(null);
+
+    try {
+      await loginWithFreighter();
+      setState('success');
+      onSuccess?.();
+    } catch (error) {
+      setState('error');
+      const message = error instanceof Error ? error.message : 'Connection failed';
+      setErrorMessage(message);
+      onError?.(message);
+    }
+  };
+
+  const isConnecting = state === 'connecting' || isLoading;
+
+  // Still checking for Freighter
+  if (isFreighterInstalled === null) {
+    return (
+      <div className={`space-y-2 ${className}`}>
+        <div className="w-full flex items-center justify-center gap-3 px-4 py-3 bg-transparent text-white font-medium rounded-lg border border-white/20">
+          <span className="text-sm text-gray-400">Checking for wallet...</span>
+        </div>
+      </div>
+    );
+  }
+
+  // If Freighter is not installed, show install link
+  if (!isFreighterInstalled) {
+    return (
+      <div className={`space-y-2 ${className}`}>
+        <a
+          href={FREIGHTER_INSTALL_URL}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="w-full flex items-center justify-center gap-3 px-4 py-3 bg-transparent hover:bg-white/5 text-white font-medium rounded-lg border border-white/20 transition-colors"
+        >
+          <FreighterIcon className="w-5 h-5" />
+          Install Freighter Wallet
+          <ExternalLinkIcon className="w-4 h-4 opacity-50" />
+        </a>
+        <p className="text-xs text-gray-400 text-center">For users with existing Stellar wallet</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className={`space-y-2 ${className}`}>
+      <button
+        type="button"
+        onClick={handleConnect}
+        disabled={isConnecting}
+        className="w-full flex items-center justify-center gap-3 px-4 py-3 bg-transparent hover:bg-white/5 text-white font-medium rounded-lg border border-white/20 transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+      >
+        {isConnecting ? (
+          <>
+            <svg aria-hidden="true" className="animate-spin h-5 w-5" viewBox="0 0 24 24">
+              <circle
+                className="opacity-25"
+                cx="12"
+                cy="12"
+                r="10"
+                stroke="currentColor"
+                strokeWidth="4"
+                fill="none"
+              />
+              <path
+                className="opacity-75"
+                fill="currentColor"
+                d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+              />
+            </svg>
+            Connecting...
+          </>
+        ) : (
+          <>
+            <FreighterIcon className="w-5 h-5" />
+            Connect with Freighter
+          </>
+        )}
+      </button>
+
+      {state === 'error' && errorMessage && (
+        <p className="text-sm text-red-400 text-center">{errorMessage}</p>
+      )}
+
+      {state === 'success' && (
+        <p className="text-sm text-green-400 text-center">Wallet connected</p>
+      )}
+    </div>
+  );
+}
+
+// Freighter icon (simplified)
+function FreighterIcon({ className }: { className?: string }) {
+  return (
+    <svg
+      aria-hidden="true"
+      className={className}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <path d="M12 2L2 7l10 5 10-5-10-5z" />
+      <path d="M2 17l10 5 10-5" />
+      <path d="M2 12l10 5 10-5" />
+    </svg>
+  );
+}
+
+// External link icon
+function ExternalLinkIcon({ className }: { className?: string }) {
+  return (
+    <svg
+      aria-hidden="true"
+      className={className}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <path d="M18 13v6a2 2 0 01-2 2H5a2 2 0 01-2-2V8a2 2 0 012-2h6" />
+      <polyline points="15,3 21,3 21,9" />
+      <line x1="10" y1="14" x2="21" y2="3" />
+    </svg>
+  );
+}
diff --git a/apps/web/src/components/auth/SocialLoginButton.tsx b/apps/web/src/components/auth/SocialLoginButton.tsx
new file mode 100644
index 00000000..2eb9d176
--- /dev/null
+++ b/apps/web/src/components/auth/SocialLoginButton.tsx
@@ -0,0 +1,211 @@
+'use client';
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+interface SocialLoginButtonProps {
+  onError?: (error: string) => void;
+  disabled?: boolean;
+  className?: string;
+}
+
+type ButtonState = 'loading' | 'ready' | 'error';
+
+const GOOGLE_CLIENT_ID = process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID;
+
+export function SocialLoginButton({ onError, disabled, className }: SocialLoginButtonProps) {
+  const [state, setState] = useState<ButtonState>('loading');
+  const [errorMessage, setErrorMessage] = useState<string | null>(null);
+  const buttonContainerRef = useRef<HTMLDivElement>(null);
+  const renderAttempts = useRef(0);
+  const hasRendered = useRef(false);
+  const maxAttempts = 20; // 10 seconds max wait
+
+  const handleError = useCallback(
+    (message: string) => {
+      setState('error');
+      setErrorMessage(message);
+      onError?.(message);
+    },
+    [onError]
+  );
+
+  useEffect(() => {
+    if (!GOOGLE_CLIENT_ID) {
+      handleError('Google Client ID not configured');
+      return;
+    }
+
+    const renderGoogleButton = () => {
+      // Wait for the ref to be available
+      if (!buttonContainerRef.current) {
+        renderAttempts.current += 1;
+        if (renderAttempts.current < maxAttempts) {
+          setTimeout(renderGoogleButton, 100);
+        } else {
+          handleError('Button container not available');
+        }
+        return;
+      }
+
+      // Check if Google Identity Services is available
+      if (typeof window !== 'undefined' && window.google?.accounts?.id) {
+        // Prevent duplicate renders
+        if (hasRendered.current) return;
+
+        try {
+          // Clear container
+          buttonContainerRef.current.innerHTML = '';
+
+          // IMPORTANT: Initialize BEFORE renderButton
+          window.google.accounts.id.initialize({
+            client_id: GOOGLE_CLIENT_ID,
+            callback: (response: unknown) => {
+              // Use global handler set by AuthProvider
+              if (window.handleGoogleCredential) {
+                window.handleGoogleCredential(
+                  response as Parameters<typeof window.handleGoogleCredential>[0]
+                );
+              }
+            },
+            auto_select: false,
+            cancel_on_tap_outside: false,
+          });
+
+          // Render official Google button
+          window.google.accounts.id.renderButton(buttonContainerRef.current, {
+            type: 'standard',
+            shape: 'rectangular',
+            theme: 'filled_blue',
+            text: 'signin_with',
+            size: 'large',
+            width: 280,
+          });
+
+          hasRendered.current = true;
+          setState('ready');
+          console.log('✅ Google Sign-In button rendered');
+        } catch (error) {
+          console.error('Error rendering Google button:', error);
+          handleError('Failed to load Google button');
+        }
+      } else {
+        // Retry if script hasn't loaded yet
+        renderAttempts.current += 1;
+
+        if (renderAttempts.current < maxAttempts) {
+          setTimeout(renderGoogleButton, 500);
+        } else {
+          handleError('Google Sign-In unavailable');
+        }
+      }
+    };
+
+    // Start trying to render immediately
+    renderGoogleButton();
+  }, [handleError]);
+
+  // Fallback: manual trigger for One Tap
+  const handleManualTrigger = () => {
+    if (window.google?.accounts?.id && GOOGLE_CLIENT_ID) {
+      // Ensure initialized before prompting
+      window.google.accounts.id.initialize({
+        client_id: GOOGLE_CLIENT_ID,
+        callback: (response: unknown) => {
+          if (window.handleGoogleCredential) {
+            window.handleGoogleCredential(
+              response as Parameters<typeof window.handleGoogleCredential>[0]
+            );
+          }
+        },
+        auto_select: false,
+      });
+
+      window.google.accounts.id.prompt((notification) => {
+        if (notification.isNotDisplayed()) {
+          const reason = notification.getNotDisplayedReason();
+          console.warn('Google One Tap not displayed:', reason);
+
+          if (reason === 'opt_out_or_no_session') {
+            handleError('Please sign in to Google first');
+          } else if (reason === 'suppressed_by_user') {
+            handleError('One Tap temporarily disabled');
+          }
+        }
+      });
+    } else {
+      handleError('Google Identity Services not loaded');
+    }
+  };
+
+  if (state === 'error') {
+    return (
+      <div className={`space-y-3 ${className}`}>
+        <button
+          type="button"
+          onClick={handleManualTrigger}
+          disabled={disabled}
+          className="w-full flex items-center justify-center gap-3 px-4 py-3 bg-white hover:bg-gray-50 text-gray-700 font-medium rounded-lg border border-gray-300 transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+        >
+          <svg aria-hidden="true" className="w-5 h-5" viewBox="0 0 24 24">
+            <path
+              fill="#4285F4"
+              d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"
+            />
+            <path
+              fill="#34A853"
+              d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
+            />
+            <path
+              fill="#FBBC05"
+              d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
+            />
+            <path
+              fill="#EA4335"
+              d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
+            />
+          </svg>
+          Continue with Google
+        </button>
+        {errorMessage && <p className="text-sm text-amber-400 text-center">{errorMessage}</p>}
+      </div>
+    );
+  }
+
+  // Always render the container - show loading overlay when not ready
+  return (
+    <div className={className}>
+      <div className="relative">
+        {/* Google button container - always rendered so ref is available */}
+        <div
+          ref={buttonContainerRef}
+          className={`flex justify-center min-h-[44px] ${disabled ? 'opacity-50 pointer-events-none' : ''} ${state === 'loading' ? 'invisible' : 'visible'}`}
+        />
+
+        {/* Loading overlay */}
+        {state === 'loading' && (
+          <div className="absolute inset-0 flex items-center justify-center">
+            <div className="flex items-center gap-2 text-gray-400">
+              <svg aria-hidden="true" className="animate-spin h-5 w-5" viewBox="0 0 24 24">
+                <circle
+                  className="opacity-25"
+                  cx="12"
+                  cy="12"
+                  r="10"
+                  stroke="currentColor"
+                  strokeWidth="4"
+                  fill="none"
+                />
+                <path
+                  className="opacity-75"
+                  fill="currentColor"
+                  d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+                />
+              </svg>
+              <span>Loading Google Sign-In...</span>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/web/src/components/layout/Navbar.tsx b/apps/web/src/components/layout/Navbar.tsx
index 9a12fea6..6e3441ee 100644
--- a/apps/web/src/components/layout/Navbar.tsx
+++ b/apps/web/src/components/layout/Navbar.tsx
@@ -1,17 +1,26 @@
 'use client';
 
-import { Home } from 'lucide-react';
+import { Home, LogOut, User } from 'lucide-react';
 import Link from 'next/link';
+import { useRouter } from 'next/navigation';
 import { useEffect, useState } from 'react';
+import { useAuth } from '~/hooks/auth/use-auth';
 import { ThemeToggle } from '../shared/theme-toggle';
 
 export function Navbar() {
   const [mounted, setMounted] = useState(false);
+  const { user, isAuthenticated, logout } = useAuth();
+  const router = useRouter();
 
   useEffect(() => {
     setMounted(true);
   }, []);
 
+  const handleLogout = () => {
+    logout();
+    router.push('/login');
+  };
+
   if (!mounted) {
     return null;
   }
@@ -25,6 +34,35 @@ export function Navbar() {
         </Link>
         <div className="flex items-center space-x-4">
           <ThemeToggle />
+          {isAuthenticated && user && (
+            <div className="flex items-center gap-3">
+              <div className="flex items-center gap-2 text-sm">
+                {user.picture ? (
+                  <img
+                    src={user.picture}
+                    alt={user.name || 'User'}
+                    className="h-8 w-8 rounded-full"
+                  />
+                ) : (
+                  <div className="flex h-8 w-8 items-center justify-center rounded-full bg-primary/10">
+                    <User className="h-4 w-4 text-primary" />
+                  </div>
+                )}
+                <span className="hidden sm:inline text-muted-foreground">
+                  {user.name || `${user.publicKey?.slice(0, 8)}...`}
+                </span>
+              </div>
+              <button
+                type="button"
+                onClick={handleLogout}
+                className="flex items-center gap-1.5 rounded-md px-3 py-1.5 text-sm text-muted-foreground hover:bg-destructive/10 hover:text-destructive transition-colors"
+                title="Logout"
+              >
+                <LogOut className="h-4 w-4" />
+                <span className="hidden sm:inline">Logout</span>
+              </button>
+            </div>
+          )}
         </div>
       </div>
     </nav>
diff --git a/apps/web/src/hooks/auth/__tests__/use-auth.test.tsx b/apps/web/src/hooks/auth/__tests__/use-auth.test.tsx
new file mode 100644
index 00000000..ceceee95
--- /dev/null
+++ b/apps/web/src/hooks/auth/__tests__/use-auth.test.tsx
@@ -0,0 +1,303 @@
+/**
+ * @jest-environment jsdom
+ */
+import { act, renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { AuthProvider, useAuth } from '../use-auth';
+
+// Mock del Stellar Social SDK
+const mockAuthenticateWithGoogleCredential = jest.fn();
+const mockConnectFreighter = jest.fn();
+
+jest.mock('~/lib/stellar-social-sdk', () => ({
+  StellarSocialSDK: jest.fn().mockImplementation(() => ({
+    authenticateWithGoogleCredential: mockAuthenticateWithGoogleCredential,
+    connectFreighter: mockConnectFreighter,
+  })),
+}));
+
+// Mock de react-hot-toast
+jest.mock('react-hot-toast', () => ({
+  __esModule: true,
+  default: {
+    loading: jest.fn(() => 'toast-id'),
+    success: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+// Mock de localStorage
+const localStorageMock = (() => {
+  let store: Record<string, string> = {};
+  return {
+    getItem: jest.fn((key: string) => store[key] || null),
+    setItem: jest.fn((key: string, value: string) => {
+      store[key] = value;
+    }),
+    removeItem: jest.fn((key: string) => {
+      delete store[key];
+    }),
+    clear: jest.fn(() => {
+      store = {};
+    }),
+  };
+})();
+
+Object.defineProperty(window, 'localStorage', { value: localStorageMock });
+
+// Mock de window.google
+const mockGoogleAccounts = {
+  id: {
+    initialize: jest.fn(),
+    renderButton: jest.fn(),
+    prompt: jest.fn(),
+    disableAutoSelect: jest.fn(),
+  },
+};
+
+Object.defineProperty(window, 'google', {
+  value: { accounts: mockGoogleAccounts },
+  writable: true,
+});
+
+// Wrapper para el provider
+const wrapper = ({ children }: { children: ReactNode }) => <AuthProvider>{children}</AuthProvider>;
+
+describe('useAuth Hook', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    localStorageMock.clear();
+
+    // Reset environment variables
+    process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID = 'test-client-id';
+    process.env.NEXT_PUBLIC_CONTRACT_ID = 'test-contract-id';
+    process.env.NEXT_PUBLIC_STELLAR_NETWORK = 'testnet';
+  });
+
+  describe('Initial State', () => {
+    it('should start with no user authenticated', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.user).toBeNull();
+      expect(result.current.account).toBeNull();
+      expect(result.current.isAuthenticated).toBe(false);
+      expect(result.current.authMethod).toBeNull();
+    });
+
+    it('should restore session from localStorage', async () => {
+      const storedUser = {
+        publicKey: 'GTEST123',
+        name: 'Test User',
+        email: 'test@example.com',
+        authMethod: 'google',
+      };
+
+      localStorageMock.setItem('stellar_social_user', JSON.stringify(storedUser));
+      localStorageMock.setItem('stellar_social_auth_method', 'google');
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.user).toEqual(storedUser);
+      expect(result.current.authMethod).toBe('google');
+      expect(result.current.isAuthenticated).toBe(true);
+    });
+  });
+
+  describe('Google Authentication', () => {
+    it('should authenticate with Google successfully', async () => {
+      const mockAccount = {
+        publicKey: 'GTEST456',
+        data: {
+          publicKey: 'GTEST456',
+          authMethods: [
+            {
+              type: 'google',
+              identifier: 'google-sub-123',
+              metadata: {
+                name: 'Google User',
+                email: 'google@example.com',
+              },
+            },
+          ],
+          createdAt: Date.now(),
+          recoveryContacts: [],
+        },
+        getBalance: jest.fn().mockResolvedValue([{ asset: 'XLM', balance: '100' }]),
+      };
+
+      mockAuthenticateWithGoogleCredential.mockResolvedValueOnce({
+        success: true,
+        account: mockAccount,
+      });
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      await act(async () => {
+        await result.current.loginWithGoogle({ credential: 'mock-google-token' });
+      });
+
+      expect(mockAuthenticateWithGoogleCredential).toHaveBeenCalledWith({
+        credential: 'mock-google-token',
+      });
+
+      expect(result.current.user?.publicKey).toBe('GTEST456');
+      expect(result.current.user?.name).toBe('Google User');
+      expect(result.current.authMethod).toBe('google');
+      expect(result.current.isAuthenticated).toBe(true);
+    });
+
+    it('should handle Google authentication failure', async () => {
+      mockAuthenticateWithGoogleCredential.mockResolvedValueOnce({
+        success: false,
+        error: 'Authentication failed',
+      });
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      await act(async () => {
+        await result.current.loginWithGoogle({ credential: 'invalid-token' });
+      });
+
+      expect(result.current.user).toBeNull();
+      expect(result.current.isAuthenticated).toBe(false);
+    });
+  });
+
+  describe('Freighter Authentication', () => {
+    it('should authenticate with Freighter successfully', async () => {
+      const mockAccount = {
+        publicKey: 'GFREIGHTER789',
+        data: {
+          publicKey: 'GFREIGHTER789',
+          authMethods: [{ type: 'freighter', identifier: 'GFREIGHTER789' }],
+          createdAt: Date.now(),
+          recoveryContacts: [],
+        },
+        getBalance: jest.fn().mockResolvedValue([{ asset: 'XLM', balance: '50' }]),
+      };
+
+      mockConnectFreighter.mockResolvedValueOnce({
+        success: true,
+        account: mockAccount,
+      });
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      await act(async () => {
+        await result.current.loginWithFreighter();
+      });
+
+      expect(mockConnectFreighter).toHaveBeenCalled();
+      expect(result.current.user?.publicKey).toBe('GFREIGHTER789');
+      expect(result.current.authMethod).toBe('freighter');
+      expect(result.current.isAuthenticated).toBe(true);
+    });
+
+    it('should handle Freighter connection failure', async () => {
+      mockConnectFreighter.mockResolvedValueOnce({
+        success: false,
+        error: 'Freighter not installed',
+      });
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      await act(async () => {
+        await result.current.loginWithFreighter();
+      });
+
+      expect(result.current.user).toBeNull();
+      expect(result.current.isAuthenticated).toBe(false);
+    });
+  });
+
+  describe('Logout', () => {
+    it('should clear user session on logout', async () => {
+      // Setup authenticated state
+      const storedUser = {
+        publicKey: 'GTEST123',
+        name: 'Test User',
+        authMethod: 'google',
+      };
+
+      localStorageMock.setItem('stellar_social_user', JSON.stringify(storedUser));
+      localStorageMock.setItem('stellar_social_auth_method', 'google');
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isAuthenticated).toBe(true);
+      });
+
+      act(() => {
+        result.current.logout();
+      });
+
+      expect(result.current.user).toBeNull();
+      expect(result.current.account).toBeNull();
+      expect(result.current.authMethod).toBeNull();
+      expect(result.current.isAuthenticated).toBe(false);
+      expect(localStorageMock.removeItem).toHaveBeenCalledWith('stellar_social_user');
+      expect(localStorageMock.removeItem).toHaveBeenCalledWith('stellar_social_auth_method');
+    });
+
+    it('should disable Google auto-select on logout', async () => {
+      const storedUser = {
+        publicKey: 'GTEST123',
+        name: 'Test User',
+        authMethod: 'google',
+      };
+
+      localStorageMock.setItem('stellar_social_user', JSON.stringify(storedUser));
+      localStorageMock.setItem('stellar_social_auth_method', 'google');
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.authMethod).toBe('google');
+      });
+
+      act(() => {
+        result.current.logout();
+      });
+
+      expect(mockGoogleAccounts.id.disableAutoSelect).toHaveBeenCalled();
+    });
+  });
+
+  describe('Balance Operations', () => {
+    it('should return empty array when no account', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      const balances = await result.current.getBalance();
+      expect(balances).toEqual([]);
+    });
+  });
+});
diff --git a/apps/web/src/hooks/auth/procted-route.tsx b/apps/web/src/hooks/auth/procted-route.tsx
index 2641002d..6702d4e1 100644
--- a/apps/web/src/hooks/auth/procted-route.tsx
+++ b/apps/web/src/hooks/auth/procted-route.tsx
@@ -9,15 +9,15 @@ import { useAuth } from './use-auth';
 interface ProtectedRouteProps {
   children: React.ReactNode;
   redirectTo?: string;
-  allowedAuthTypes?: ('email' | 'wallet')[];
+  allowedAuthTypes?: ('google' | 'freighter')[];
 }
 
 export default function ProtectedRoute({
   children,
   redirectTo = '/login',
-  allowedAuthTypes = ['email', 'wallet'],
+  allowedAuthTypes = ['google', 'freighter'],
 }: ProtectedRouteProps) {
-  const { isAuthenticated, authType, isLoading } = useAuth();
+  const { isAuthenticated, authMethod, isLoading } = useAuth();
   const router = useRouter();
   const [isChecking, setIsChecking] = useState(true);
 
@@ -30,26 +30,26 @@ export default function ProtectedRoute({
         return;
       }
 
-      if (authType && !allowedAuthTypes.includes(authType)) {
-        console.log('🚫 Auth type not allowed:', authType, 'Allowed:', allowedAuthTypes);
+      if (authMethod && !allowedAuthTypes.includes(authMethod)) {
+        console.log('Auth method not allowed:', authMethod, 'Allowed:', allowedAuthTypes);
         router.push(redirectTo);
         return;
       }
     }
-  }, [isAuthenticated, authType, isLoading, router, redirectTo, allowedAuthTypes]);
+  }, [isAuthenticated, authMethod, isLoading, router, redirectTo, allowedAuthTypes]);
 
   if (isLoading || isChecking) {
     return (
-      <div className="min-h-screen flex items-center justify-center bg-gray-50 dark:bg-gray-900">
+      <div className="min-h-screen flex items-center justify-center bg-[#0B1320]">
         <div className="text-center">
-          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600 mx-auto mb-4" />
-          <p className="text-gray-600 dark:text-gray-400">Checking authentication...</p>
+          <div className="animate-spin rounded-full h-12 w-12 border-t-2 border-b-2 border-blue-500 mx-auto mb-4" />
+          <p className="text-gray-400">Checking authentication...</p>
         </div>
       </div>
     );
   }
 
-  if (!isAuthenticated || (authType && !allowedAuthTypes.includes(authType))) {
+  if (!isAuthenticated || (authMethod && !allowedAuthTypes.includes(authMethod))) {
     return null;
   }
 
diff --git a/apps/web/src/hooks/auth/use-auth.tsx b/apps/web/src/hooks/auth/use-auth.tsx
index c967a4b1..5b072ded 100644
--- a/apps/web/src/hooks/auth/use-auth.tsx
+++ b/apps/web/src/hooks/auth/use-auth.tsx
@@ -1,246 +1,372 @@
 'use client';
 
-import { type ReactNode, createContext, useContext, useEffect, useState } from 'react';
-import { signTransactionWithFreighter } from '~/lib/freighter-utils';
-import { getNetworkName, getNetworkPassphrase, logNetworkInfo } from '~/lib/network-utils';
-import { apiUtils, authAPI } from '../../services/api';
-import { useWallet } from '../useWallet';
-
-interface User {
-  id: string;
-  email?: string;
-  name: string;
-  publicKey?: string;
-  authType?: 'email' | 'wallet';
-}
-
-interface AuthContextType {
-  user: User | null;
-  isLoading: boolean;
-  login: (email: string, password: string) => Promise<void>;
-  register: (email: string, password: string, fullName: string) => Promise<void>;
-  loginWithWallet: () => Promise<void>;
-  logout: () => Promise<void>;
-  isAuthenticated: boolean;
-  authType: 'email' | 'wallet' | null;
-}
+import {
+  type ReactNode,
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+} from 'react';
+import toast from 'react-hot-toast';
+import { StellarSocialSDK } from '~/lib/stellar-social-sdk';
+import type {
+  AuthContextType,
+  BalanceInfo,
+  CredentialResponse,
+  SocialUser,
+  StellarSocialAccount,
+} from '~/types/auth';
+
+// Configuración del SDK
+const CONTRACT_ID =
+  process.env.NEXT_PUBLIC_CONTRACT_ID || 'CALZGCSB3P3WEBLW3QTF5Y4WEALEVTYUYBC7KBGQ266GDINT7U4E74KW';
+const GOOGLE_CLIENT_ID = process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID;
+const STELLAR_NETWORK = (process.env.NEXT_PUBLIC_STELLAR_NETWORK || 'testnet') as
+  | 'testnet'
+  | 'mainnet';
+
+// Claves de localStorage
+const STORAGE_KEYS = {
+  USER: 'stellar_social_user',
+  AUTH_METHOD: 'stellar_social_auth_method',
+} as const;
 
 const AuthContext = createContext<AuthContextType>({
   user: null,
-  isLoading: false,
-  login: async () => {},
-  register: async () => {},
-  loginWithWallet: async () => {},
-  logout: async () => {},
+  account: null,
   isAuthenticated: false,
-  authType: null,
+  isLoading: true,
+  authMethod: null,
+  loginWithGoogle: async () => {},
+  loginWithFreighter: async () => {},
+  logout: () => {},
+  getBalance: async () => [],
+  sendPayment: async () => '',
 });
 
 export function AuthProvider({ children }: { children: ReactNode }) {
-  const [user, setUser] = useState<User | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [authType, setAuthType] = useState<'email' | 'wallet' | null>(null);
-  const { network, networkPassphrase, getPublicKey } = useWallet();
+  const [user, setUser] = useState<SocialUser | null>(null);
+  const [account, setAccount] = useState<StellarSocialAccount | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [authMethod, setAuthMethod] = useState<'google' | 'freighter' | null>(null);
+  const [sdk, setSdk] = useState<StellarSocialSDK | null>(null);
+
+  // Refs para acceder al estado actual en callbacks
+  const sdkRef = useRef<StellarSocialSDK | null>(null);
+  const setUserRef = useRef(setUser);
+  const setAccountRef = useRef(setAccount);
+  const setAuthMethodRef = useRef(setAuthMethod);
+  const setIsLoadingRef = useRef(setIsLoading);
+
+  // Actualizar refs cuando cambia el estado
+  useEffect(() => {
+    sdkRef.current = sdk;
+  }, [sdk]);
 
   useEffect(() => {
-    const checkAuth = () => {
-      const storedUser = localStorage.getItem('user');
-      const storedAuthType = localStorage.getItem('authType') as 'email' | 'wallet' | null;
+    setUserRef.current = setUser;
+    setAccountRef.current = setAccount;
+    setAuthMethodRef.current = setAuthMethod;
+    setIsLoadingRef.current = setIsLoading;
+  }, []);
 
-      if (storedUser) {
-        try {
-          const parsedUser = JSON.parse(storedUser);
+  // Inicializar SDK
+  useEffect(() => {
+    const initSDK = async () => {
+      try {
+        const stellarSDK = new StellarSocialSDK({
+          contractId: CONTRACT_ID,
+          network: STELLAR_NETWORK,
+          googleClientId: GOOGLE_CLIENT_ID,
+        });
+
+        setSdk(stellarSDK);
+        console.log('✅ Stellar Social SDK initialized');
+      } catch (error) {
+        console.error('❌ Failed to initialize SDK:', error);
+        toast.error('Failed to initialize authentication system');
+      }
+    };
+
+    initSDK();
+  }, []);
+
+  // Restaurar sesión desde localStorage
+  useEffect(() => {
+    const restoreSession = () => {
+      try {
+        const storedUser = localStorage.getItem(STORAGE_KEYS.USER);
+        const storedAuthMethod = localStorage.getItem(STORAGE_KEYS.AUTH_METHOD) as
+          | 'google'
+          | 'freighter'
+          | null;
+
+        if (storedUser && storedAuthMethod) {
+          const parsedUser = JSON.parse(storedUser) as SocialUser;
           setUser(parsedUser);
-          setAuthType(storedAuthType);
-        } catch (error) {
-          console.error('Error parsing stored user:', error);
-          apiUtils.clearAuth();
+          setAuthMethod(storedAuthMethod);
+          console.log('✅ Session restored for:', parsedUser.name || parsedUser.publicKey);
         }
+      } catch (error) {
+        console.error('Error restoring session:', error);
+        clearStorage();
+      } finally {
+        setIsLoading(false);
       }
     };
 
-    checkAuth();
+    restoreSession();
   }, []);
 
-  const login = async (email: string, password: string) => {
-    setIsLoading(true);
-    try {
-      const response = (await authAPI.login(email, password)) as {
-        token: string;
-        user: { id: string; email: string; name: string };
-      };
-      const userData: User = {
-        id: response.user.id,
-        email: response.user.email,
-        name: response.user.name,
-        authType: 'email',
-      };
-
-      setUser(userData);
-      setAuthType('email');
-      localStorage.setItem('authToken', response.token);
-      localStorage.setItem('user', JSON.stringify(userData));
-      localStorage.setItem('authType', 'email');
-    } catch (error) {
-      console.error('Login failed:', error);
-      throw error;
-    } finally {
-      setIsLoading(false);
-    }
-  };
+  // Restore account when SDK is ready and we have a stored session
+  useEffect(() => {
+    const restoreAccount = async () => {
+      if (!sdk || !user || account) return;
 
-  const register = async (email: string, password: string, fullName: string) => {
-    setIsLoading(true);
-    try {
-      const response = (await authAPI.register(email, password, fullName)) as {
-        token: string;
-        user: { id: string; email: string; name: string };
-      };
-      const userData: User = {
-        id: response.user.id,
-        email: response.user.email,
-        name: response.user.name,
-        authType: 'email',
-      };
-
-      setUser(userData);
-      setAuthType('email');
-      localStorage.setItem('authToken', response.token);
-      localStorage.setItem('user', JSON.stringify(userData));
-      localStorage.setItem('authType', 'email');
-    } catch (error) {
-      console.error('Registration failed:', error);
-      throw error;
-    } finally {
-      setIsLoading(false);
-    }
-  };
+      try {
+        if (authMethod === 'freighter') {
+          // For Freighter, try to reconnect silently
+          const { isConnected } = await import('@stellar/freighter-api');
+          const result = await isConnected();
+
+          if (result.isConnected === true) {
+            const reconnectResult = await sdk.connectFreighter();
+            if (reconnectResult.success && reconnectResult.account) {
+              setAccount(reconnectResult.account as StellarSocialAccount);
+              console.log('✅ Freighter account restored');
+            }
+          } else {
+            // Freighter not available, clear session
+            console.warn('Freighter not available, clearing session');
+            clearStorage();
+            setUser(null);
+            setAuthMethod(null);
+          }
+        }
+        // For Google, user must re-authenticate to get account
+        // The UI should prompt for re-auth when account is needed
+      } catch (error) {
+        console.error('Error restoring account:', error);
+      }
+    };
 
-  const loginWithWallet = async () => {
-    setIsLoading(true);
-    try {
-      // Get public key (this handles connection if needed)
-      const walletPublicKey = await getPublicKey();
-      if (!walletPublicKey) {
-        throw new Error('Failed to get public key from wallet');
+    restoreAccount();
+  }, [sdk, user, authMethod, account]);
+
+  // Configurar Google OAuth cuando el SDK esté listo
+  useEffect(() => {
+    if (!sdk || !GOOGLE_CLIENT_ID) return;
+
+    const setupGoogleOAuth = () => {
+      if (typeof window !== 'undefined' && window.google?.accounts?.id) {
+        // Asignar callback global
+        window.handleGoogleCredential = handleGoogleAuthComplete;
+
+        // Inicializar Google Identity Services
+        window.google.accounts.id.initialize({
+          client_id: GOOGLE_CLIENT_ID,
+          callback: handleGoogleAuthComplete,
+          auto_select: false,
+          cancel_on_tap_outside: false,
+          ux_mode: 'popup',
+          context: 'signin',
+          itp_support: true,
+          use_fedcm_for_prompt: true,
+        });
+
+        console.log('✅ Google OAuth initialized');
+      } else {
+        // Reintentar si el script de Google aún no ha cargado
+        setTimeout(setupGoogleOAuth, 500);
       }
+    };
 
-      console.log('🔑 Using public key:', walletPublicKey);
+    // Esperar a que cargue el script de Google
+    setTimeout(setupGoogleOAuth, 1000);
+  }, [sdk]);
 
-      // Debug network information
-      logNetworkInfo(network, 'TESTNET');
+  // Handler para autenticación con Google
+  const handleGoogleAuthComplete = useCallback(async (credentialResponse: CredentialResponse) => {
+    const currentSdk = sdkRef.current;
 
-      // Request challenge from backend
-      const challengeResponse = await authAPI.requestChallenge(walletPublicKey);
+    if (!credentialResponse?.credential) {
+      toast.error('No credential received from Google');
+      return;
+    }
 
-      try {
-        const { TransactionBuilder, Account, Memo, BASE_FEE } = await import(
-          '@stellar/stellar-sdk'
-        );
+    if (!currentSdk) {
+      toast.error('SDK not initialized');
+      return;
+    }
 
-        const challengeText = challengeResponse.challenge;
-        if (challengeText.length > 28) {
-          throw new Error('Challenge too long for transaction memo');
-        }
+    setIsLoadingRef.current(true);
+    const toastId = toast.loading('Creating your Stellar account...');
 
-        // Use the wallet's current network, but ensure it matches what we expect
-        const walletNetworkPassphrase = networkPassphrase || getNetworkPassphrase(network);
-        const targetNetworkName = getNetworkName(network);
-
-        console.log('🌐 Transaction Network Info:');
-        console.log('  Wallet Network:', network);
-        console.log('  Wallet Passphrase:', networkPassphrase);
-        console.log('  Using Passphrase:', walletNetworkPassphrase);
-        console.log('  Target Network Name:', targetNetworkName);
-
-        // Create memo-only transaction (no operations as backend expects)
-        const account = new Account(walletPublicKey, '0');
-        const transaction = new TransactionBuilder(account, {
-          fee: BASE_FEE,
-          networkPassphrase: walletNetworkPassphrase, // Use wallet's actual network
-        })
-          .addMemo(Memo.text(challengeText)) // Only memo, no operations
-          .setTimeout(30)
-          .build();
-
-        console.log('📝 Transaction created for network:', walletNetworkPassphrase);
-
-        // Sign transaction - use the wallet's current network
-        const signResult = await signTransactionWithFreighter(transaction.toXDR(), {
-          network: targetNetworkName,
-          networkPassphrase: walletNetworkPassphrase,
-          address: walletPublicKey,
-        });
+    try {
+      const result = await currentSdk.authenticateWithGoogleCredential(credentialResponse);
+
+      if (result.success && result.account) {
+        const stellarAccount = result.account as StellarSocialAccount;
+        const authMethodData = stellarAccount.data.authMethods[0];
+
+        const socialUser: SocialUser = {
+          publicKey: stellarAccount.publicKey,
+          name: authMethodData?.metadata?.name,
+          email: authMethodData?.metadata?.email,
+          picture: authMethodData?.metadata?.picture,
+          authMethod: 'google',
+        };
 
-        if (signResult.error) {
-          throw new Error(signResult.error);
-        }
+        // Guardar en estado
+        setUserRef.current(socialUser);
+        setAccountRef.current(stellarAccount);
+        setAuthMethodRef.current('google');
 
-        if (!signResult.signedTxXdr) {
-          throw new Error('No signed transaction returned');
-        }
+        // Persistir en localStorage
+        localStorage.setItem(STORAGE_KEYS.USER, JSON.stringify(socialUser));
+        localStorage.setItem(STORAGE_KEYS.AUTH_METHOD, 'google');
 
-        console.log('✅ Transaction signed successfully');
+        toast.success(`Welcome ${socialUser.name || 'User'}!`, { id: toastId });
+        console.log('✅ Google auth successful:', socialUser.publicKey);
+      } else {
+        throw new Error(result.error || 'Authentication failed');
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Error de autenticación';
+      toast.error(errorMessage, { id: toastId });
+      console.error('❌ Google auth failed:', error);
+    } finally {
+      setIsLoadingRef.current(false);
+    }
+  }, []);
+
+  // Login con Google (trigger manual)
+  const loginWithGoogle = useCallback(
+    async (credentialResponse: CredentialResponse) => {
+      await handleGoogleAuthComplete(credentialResponse);
+    },
+    [handleGoogleAuthComplete]
+  );
+
+  // Login con Freighter
+  const loginWithFreighter = useCallback(async () => {
+    if (!sdk) {
+      toast.error('SDK not initialized');
+      return;
+    }
 
-        // Authenticate with backend
-        const authResponse = await authAPI.authenticateWallet(
-          walletPublicKey,
-          signResult.signedTxXdr,
-          challengeResponse.challenge
-        );
+    setIsLoading(true);
+    const toastId = toast.loading('Connecting to Freighter...');
+
+    try {
+      const result = await sdk.connectFreighter();
 
-        const userData: User = {
-          id: (authResponse.user as { id: string; name?: string }).id,
-          name: (authResponse.user as { id: string; name?: string }).name || 'Wallet User',
-          publicKey: walletPublicKey,
-          authType: 'wallet',
+      if (result.success && result.account) {
+        const stellarAccount = result.account as StellarSocialAccount;
+
+        const socialUser: SocialUser = {
+          publicKey: stellarAccount.publicKey,
+          name: 'Freighter User',
+          authMethod: 'freighter',
         };
 
-        setUser(userData);
-        setAuthType('wallet');
-        localStorage.setItem('user', JSON.stringify(userData));
-        localStorage.setItem('authType', 'wallet');
+        // Guardar en estado
+        setUser(socialUser);
+        setAccount(stellarAccount);
+        setAuthMethod('freighter');
+
+        // Persistir en localStorage
+        localStorage.setItem(STORAGE_KEYS.USER, JSON.stringify(socialUser));
+        localStorage.setItem(STORAGE_KEYS.AUTH_METHOD, 'freighter');
 
-        console.log('🎉 Wallet authentication successful!');
-      } catch (signError) {
-        console.error('Error creating or signing transaction:', signError);
-        throw new Error('Failed to sign authentication transaction');
+        toast.success('Wallet connected!', { id: toastId });
+        console.log('✅ Freighter auth successful:', socialUser.publicKey);
+      } else {
+        throw new Error(result.error || 'Failed to connect Freighter');
       }
     } catch (error) {
-      console.error('Wallet login failed:', error);
-      throw error;
+      const errorMessage = error instanceof Error ? error.message : 'Failed to connect wallet';
+      toast.error(errorMessage, { id: toastId });
+      console.error('❌ Freighter auth failed:', error);
     } finally {
       setIsLoading(false);
     }
-  };
+  }, [sdk]);
+
+  // Logout
+  const logout = useCallback(() => {
+    // Limpiar estado
+    setUser(null);
+    setAccount(null);
+    setAuthMethod(null);
+
+    // Limpiar localStorage
+    clearStorage();
+
+    // Revocar acceso de Google si estaba autenticado con Google
+    if (authMethod === 'google' && window.google?.accounts?.id) {
+      window.google.accounts.id.disableAutoSelect();
+    }
+
+    toast.success('Logged out');
+    console.log('✅ Logged out');
+  }, [authMethod]);
+
+  // Obtener balance
+  const getBalance = useCallback(async (): Promise<BalanceInfo[]> => {
+    if (!account) {
+      console.warn('No account available for balance check');
+      return [];
+    }
 
-  const logout = async () => {
-    setIsLoading(true);
     try {
-      await authAPI.logout();
+      const balances = await account.getBalance();
+      return balances;
     } catch (error) {
-      console.error('Logout failed:', error);
-    } finally {
-      setUser(null);
-      setAuthType(null);
-      apiUtils.clearAuth();
-      setIsLoading(false);
+      console.error('Error fetching balance:', error);
+      return [];
     }
-  };
+  }, [account]);
 
-  const isAuthenticated = !!user;
+  // Enviar pago
+  const sendPayment = useCallback(
+    async (to: string, amount: string, memo?: string): Promise<string> => {
+      if (!account) {
+        throw new Error('No active account');
+      }
+
+      const toastId = toast.loading('Sending payment...');
+
+      try {
+        const txHash = await account.sendPayment(to, amount, undefined, memo);
+        toast.success('Payment sent successfully', { id: toastId });
+        return txHash;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Failed to send payment';
+        toast.error(errorMessage, { id: toastId });
+        throw error;
+      }
+    },
+    [account]
+  );
+
+  const isAuthenticated = !!user && !!user.publicKey;
 
   return (
     <AuthContext.Provider
       value={{
         user,
+        account,
+        isAuthenticated,
         isLoading,
-        login,
-        register,
-        loginWithWallet,
+        authMethod,
+        loginWithGoogle,
+        loginWithFreighter,
         logout,
-        isAuthenticated,
-        authType,
+        getBalance,
+        sendPayment,
       }}
     >
       {children}
@@ -248,4 +374,14 @@ export function AuthProvider({ children }: { children: ReactNode }) {
   );
 }
 
+// Helper para limpiar storage
+function clearStorage() {
+  localStorage.removeItem(STORAGE_KEYS.USER);
+  localStorage.removeItem(STORAGE_KEYS.AUTH_METHOD);
+  // Limpiar claves legacy también
+  localStorage.removeItem('user');
+  localStorage.removeItem('authToken');
+  localStorage.removeItem('authType');
+}
+
 export const useAuth = () => useContext(AuthContext);
diff --git a/apps/web/src/hooks/useUserRole.tsx b/apps/web/src/hooks/useUserRole.tsx
index 753421d8..d0f36574 100644
--- a/apps/web/src/hooks/useUserRole.tsx
+++ b/apps/web/src/hooks/useUserRole.tsx
@@ -35,7 +35,8 @@ export function useUserRole(): UseUserRoleReturn {
 
         // Try to fetch profile from API first
         try {
-          const response = await profileAPI.getUserProfile(user.id);
+          const userId = user.publicKey || 'unknown';
+          const response = await profileAPI.getUserProfile(userId);
           const profile = response.data;
 
           // Extract host information from profile
diff --git a/apps/web/src/lib/stellar-social-sdk.ts b/apps/web/src/lib/stellar-social-sdk.ts
new file mode 100644
index 00000000..97b308e8
--- /dev/null
+++ b/apps/web/src/lib/stellar-social-sdk.ts
@@ -0,0 +1,10 @@
+// Re-export del Stellar Social SDK para uso en la aplicación
+// Este archivo facilita las importaciones y permite cambiar la fuente del SDK fácilmente
+
+export { StellarSocialSDK } from '../../stellar-social-sdk/dist/index.esm.js';
+export type {
+  SocialAuthConfig,
+  AuthMethod,
+  AuthResult,
+  SocialAccountData,
+} from '../../stellar-social-sdk/dist/index.esm.js';
diff --git a/apps/web/src/types/auth.ts b/apps/web/src/types/auth.ts
new file mode 100644
index 00000000..bb880fa6
--- /dev/null
+++ b/apps/web/src/types/auth.ts
@@ -0,0 +1,107 @@
+// Tipos para el sistema de autenticación con Stellar Social SDK
+
+export interface CredentialResponse {
+  credential: string;
+  select_by?: string;
+  clientId?: string;
+}
+
+export interface BalanceInfo {
+  asset: string;
+  balance: string;
+}
+
+export interface SocialUser {
+  publicKey: string;
+  name?: string;
+  email?: string;
+  picture?: string;
+  authMethod: 'google' | 'freighter';
+}
+
+export interface StellarSocialAccount {
+  publicKey: string;
+  data: {
+    publicKey: string;
+    authMethods: AuthMethodData[];
+    createdAt: number;
+    recoveryContacts: string[];
+  };
+  getBalance(): Promise<BalanceInfo[]>;
+  sendPayment(destination: string, amount: string, asset?: unknown, memo?: string): Promise<string>;
+  addAuthMethod(method: AuthMethodData): Promise<boolean>;
+}
+
+export interface AuthMethodData {
+  type: string;
+  identifier: string;
+  metadata?: {
+    name?: string;
+    email?: string;
+    picture?: string;
+  };
+}
+
+export interface AuthContextType {
+  // Estado
+  user: SocialUser | null;
+  account: StellarSocialAccount | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  authMethod: 'google' | 'freighter' | null;
+
+  // Métodos
+  loginWithGoogle: (credentialResponse: CredentialResponse) => Promise<void>;
+  loginWithFreighter: () => Promise<void>;
+  logout: () => void;
+  getBalance: () => Promise<BalanceInfo[]>;
+  sendPayment: (to: string, amount: string, memo?: string) => Promise<string>;
+}
+
+// Extender Window para Google Identity Services
+declare global {
+  interface Window {
+    google?: {
+      accounts: {
+        id: {
+          initialize: (config: GoogleIdConfig) => void;
+          renderButton: (element: HTMLElement, config: GoogleButtonConfig) => void;
+          prompt: (callback?: (notification: PromptNotification) => void) => void;
+          disableAutoSelect: () => void;
+          revoke: (hint: string, callback?: () => void) => void;
+        };
+      };
+    };
+    handleGoogleCredential?: (response: CredentialResponse) => void;
+  }
+}
+
+export interface GoogleIdConfig {
+  client_id: string;
+  callback: (response: CredentialResponse) => void;
+  auto_select?: boolean;
+  cancel_on_tap_outside?: boolean;
+  ux_mode?: 'popup' | 'redirect';
+  context?: 'signin' | 'signup' | 'use';
+  itp_support?: boolean;
+  use_fedcm_for_prompt?: boolean;
+}
+
+export interface GoogleButtonConfig {
+  type?: 'standard' | 'icon';
+  theme?: 'outline' | 'filled_blue' | 'filled_black';
+  size?: 'large' | 'medium' | 'small';
+  text?: 'signin_with' | 'signup_with' | 'continue_with' | 'signin';
+  shape?: 'rectangular' | 'pill' | 'circle' | 'square';
+  logo_alignment?: 'left' | 'center';
+  width?: string | number;
+}
+
+export interface PromptNotification {
+  isNotDisplayed(): boolean;
+  isSkippedMoment(): boolean;
+  isDismissedMoment(): boolean;
+  getNotDisplayedReason(): string;
+  getSkippedReason(): string;
+  getDismissedReason(): string;
+}
diff --git a/apps/web/stellar-social-sdk/package-lock.json b/apps/web/stellar-social-sdk/package-lock.json
new file mode 100644
index 00000000..b92a272b
--- /dev/null
+++ b/apps/web/stellar-social-sdk/package-lock.json
@@ -0,0 +1,1616 @@
+{
+  "name": "stellar-social-sdk",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "stellar-social-sdk",
+      "version": "0.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "@stellar/freighter-api": "^4.1.0",
+        "@stellar/stellar-sdk": "^12.3.0",
+        "axios": "^1.6.0",
+        "crypto-js": "^4.2.0",
+        "jose": "^5.2.0"
+      },
+      "devDependencies": {
+        "@rollup/plugin-commonjs": "^25.0.0",
+        "@rollup/plugin-node-resolve": "^15.2.0",
+        "@rollup/plugin-typescript": "^11.1.0",
+        "@types/crypto-js": "^4.2.0",
+        "@types/node": "^20.10.0",
+        "rollup": "^4.0.0",
+        "rollup-plugin-dts": "^6.1.0",
+        "typescript": "^5.3.0"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.4.tgz",
+      "integrity": "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/plugin-commonjs": {
+      "version": "25.0.8",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-25.0.8.tgz",
+      "integrity": "sha512-ZEZWTK5n6Qde0to4vS9Mr5x/0UZoqCxPVR9KRUjU4kA2sO7GEUn1fop0DAwpO6z0Nw/kJON9bDmSxdWxO/TT1A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "commondir": "^1.0.1",
+        "estree-walker": "^2.0.2",
+        "glob": "^8.0.3",
+        "is-reference": "1.2.1",
+        "magic-string": "^0.30.3"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.68.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-node-resolve": {
+      "version": "15.3.1",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.3.1.tgz",
+      "integrity": "sha512-tgg6b91pAybXHJQMAAwW9VuWBO6Thi+q7BCNARLwSqlmsHz0XYURtGvh/AuwSADXSI4h/2uHbs7s4FzlZDGSGA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "@types/resolve": "1.20.2",
+        "deepmerge": "^4.2.2",
+        "is-module": "^1.0.0",
+        "resolve": "^1.22.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.78.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-typescript": {
+      "version": "11.1.6",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-11.1.6.tgz",
+      "integrity": "sha512-R92yOmIACgYdJ7dJ97p4K69I8gg6IEHt8M7dUBxN3W6nrO8uUxX5ixl0yU/N3aZTi8WhPuICvOHXQvF6FaykAA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.1.0",
+        "resolve": "^1.22.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.14.0||^3.0.0||^4.0.0",
+        "tslib": "*",
+        "typescript": ">=3.7.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        },
+        "tslib": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.2.0.tgz",
+      "integrity": "sha512-qWJ2ZTbmumwiLFomfzTyt5Kng4hwPi9rwCYN4SHb6eaRU1KNO4ccxINHr/VhH4GgPlt1XfSTLX2LBTme8ne4Zw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.45.1.tgz",
+      "integrity": "sha512-NEySIFvMY0ZQO+utJkgoMiCAjMrGvnbDLHvcmlA33UXJpYBCvlBEbMMtV837uCkS+plG2umfhn0T5mMAxGrlRA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.45.1.tgz",
+      "integrity": "sha512-ujQ+sMXJkg4LRJaYreaVx7Z/VMgBBd89wGS4qMrdtfUFZ+TSY5Rs9asgjitLwzeIbhwdEhyj29zhst3L1lKsRQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.45.1.tgz",
+      "integrity": "sha512-FSncqHvqTm3lC6Y13xncsdOYfxGSLnP+73k815EfNmpewPs+EyM49haPS105Rh4aF5mJKywk9X0ogzLXZzN9lA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.45.1.tgz",
+      "integrity": "sha512-2/vVn/husP5XI7Fsf/RlhDaQJ7x9zjvC81anIVbr4b/f0xtSmXQTFcGIQ/B1cXIYM6h2nAhJkdMHTnD7OtQ9Og==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.45.1.tgz",
+      "integrity": "sha512-4g1kaDxQItZsrkVTdYQ0bxu4ZIQ32cotoQbmsAnW1jAE4XCMbcBPDirX5fyUzdhVCKgPcrwWuucI8yrVRBw2+g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.45.1.tgz",
+      "integrity": "sha512-L/6JsfiL74i3uK1Ti2ZFSNsp5NMiM4/kbbGEcOCps99aZx3g8SJMO1/9Y0n/qKlWZfn6sScf98lEOUe2mBvW9A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.45.1.tgz",
+      "integrity": "sha512-RkdOTu2jK7brlu+ZwjMIZfdV2sSYHK2qR08FUWcIoqJC2eywHbXr0L8T/pONFwkGukQqERDheaGTeedG+rra6Q==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.45.1.tgz",
+      "integrity": "sha512-3kJ8pgfBt6CIIr1o+HQA7OZ9mp/zDk3ctekGl9qn/pRBgrRgfwiffaUmqioUGN9hv0OHv2gxmvdKOkARCtRb8Q==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.45.1.tgz",
+      "integrity": "sha512-k3dOKCfIVixWjG7OXTCOmDfJj3vbdhN0QYEqB+OuGArOChek22hn7Uy5A/gTDNAcCy5v2YcXRJ/Qcnm4/ma1xw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.45.1.tgz",
+      "integrity": "sha512-PmI1vxQetnM58ZmDFl9/Uk2lpBBby6B6rF4muJc65uZbxCs0EA7hhKCk2PKlmZKuyVSHAyIw3+/SiuMLxKxWog==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.45.1.tgz",
+      "integrity": "sha512-9UmI0VzGmNJ28ibHW2GpE2nF0PBQqsyiS4kcJ5vK+wuwGnV5RlqdczVocDSUfGX/Na7/XINRVoUgJyFIgipoRg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.45.1.tgz",
+      "integrity": "sha512-7nR2KY8oEOUTD3pBAxIBBbZr0U7U+R9HDTPNy+5nVVHDXI4ikYniH1oxQz9VoB5PbBU1CZuDGHkLJkd3zLMWsg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.45.1.tgz",
+      "integrity": "sha512-nlcl3jgUultKROfZijKjRQLUu9Ma0PeNv/VFHkZiKbXTBQXhpytS8CIj5/NfBeECZtY2FJQubm6ltIxm/ftxpw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.45.1.tgz",
+      "integrity": "sha512-HJV65KLS51rW0VY6rvZkiieiBnurSzpzore1bMKAhunQiECPuxsROvyeaot/tcK3A3aGnI+qTHqisrpSgQrpgA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.45.1.tgz",
+      "integrity": "sha512-NITBOCv3Qqc6hhwFt7jLV78VEO/il4YcBzoMGGNxznLgRQf43VQDae0aAzKiBeEPIxnDrACiMgbqjuihx08OOw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.45.1.tgz",
+      "integrity": "sha512-+E/lYl6qu1zqgPEnTrs4WysQtvc/Sh4fC2nByfFExqgYrqkKWp1tWIbe+ELhixnenSpBbLXNi6vbEEJ8M7fiHw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.45.1.tgz",
+      "integrity": "sha512-a6WIAp89p3kpNoYStITT9RbTbTnqarU7D8N8F2CV+4Cl9fwCOZraLVuVFvlpsW0SbIiYtEnhCZBPLoNdRkjQFw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.45.1.tgz",
+      "integrity": "sha512-T5Bi/NS3fQiJeYdGvRpTAP5P02kqSOpqiopwhj0uaXB6nzs5JVi2XMJb18JUSKhCOX8+UE1UKQufyD6Or48dJg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.45.1.tgz",
+      "integrity": "sha512-lxV2Pako3ujjuUe9jiU3/s7KSrDfH6IgTSQOnDWr9aJ92YsFd7EurmClK0ly/t8dzMkDtd04g60WX6yl0sGfdw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.45.1.tgz",
+      "integrity": "sha512-M/fKi4sasCdM8i0aWJjCSFm2qEnYRR8AMLG2kxp6wD13+tMGA4Z1tVAuHkNRjud5SW2EM3naLuK35w9twvf6aA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@stellar/freighter-api": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@stellar/freighter-api/-/freighter-api-4.1.0.tgz",
+      "integrity": "sha512-5iaENUG8AoSlBr771XVou4wjYxfcl+SRyFZydwwGEuHm1XGDu/HLXFifXbRFoU14/5rZYouycnv1uJCuFIeBxg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "buffer": "^6.0.3",
+        "semver": "^7.6.3"
+      }
+    },
+    "node_modules/@stellar/js-xdr": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@stellar/js-xdr/-/js-xdr-3.1.2.tgz",
+      "integrity": "sha512-VVolPL5goVEIsvuGqDc5uiKxV03lzfWdvYg1KikvwheDmTBO68CKDji3bAZ/kppZrx5iTA8z3Ld5yuytcvhvOQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@stellar/stellar-base": {
+      "version": "12.1.1",
+      "resolved": "https://registry.npmjs.org/@stellar/stellar-base/-/stellar-base-12.1.1.tgz",
+      "integrity": "sha512-gOBSOFDepihslcInlqnxKZdIW9dMUO1tpOm3AtJR33K2OvpXG6SaVHCzAmCFArcCqI9zXTEiSoh70T48TmiHJA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@stellar/js-xdr": "^3.1.2",
+        "base32.js": "^0.1.0",
+        "bignumber.js": "^9.1.2",
+        "buffer": "^6.0.3",
+        "sha.js": "^2.3.6",
+        "tweetnacl": "^1.0.3"
+      },
+      "optionalDependencies": {
+        "sodium-native": "^4.1.1"
+      }
+    },
+    "node_modules/@stellar/stellar-sdk": {
+      "version": "12.3.0",
+      "resolved": "https://registry.npmjs.org/@stellar/stellar-sdk/-/stellar-sdk-12.3.0.tgz",
+      "integrity": "sha512-F2DYFop/M5ffXF0lvV5Ezjk+VWNKg0QDX8gNhwehVU3y5LYA3WAY6VcCarMGPaG9Wdgoeh1IXXzOautpqpsltw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@stellar/stellar-base": "^12.1.1",
+        "axios": "^1.7.7",
+        "bignumber.js": "^9.1.2",
+        "eventsource": "^2.0.2",
+        "randombytes": "^2.1.0",
+        "toml": "^3.0.0",
+        "urijs": "^1.19.1"
+      }
+    },
+    "node_modules/@types/crypto-js": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@types/crypto-js/-/crypto-js-4.2.2.tgz",
+      "integrity": "sha512-sDOLlVbHhXpAUAL0YHDUUwDZf3iN4Bwi4W6a0W0b+QcAezUbRtH4FVb+9J4h+XFPW7l/gQ9F8qC7P+Ec4k8QVQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.9",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.9.tgz",
+      "integrity": "sha512-cuVNgarYWZqxRJDQHEB58GEONhOK79QVR/qYx4S7kcUObQvUwvFnYxJuuHUKm2aieN9X3yZB4LZsuYNU1Qphsw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/resolve": {
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz",
+      "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/available-typed-arrays": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
+      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "possible-typed-array-names": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/axios": {
+      "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.11.0.tgz",
+      "integrity": "sha512-1Lx3WLFQWm3ooKDYZD1eXmoGO9fxYQjrycfHFC8P0sCfQVXyROp0p9PFWBehewBOdCwHc+f/b8I0fMto5eSfwA==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.4",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/bare-addon-resolve": {
+      "version": "1.9.4",
+      "resolved": "https://registry.npmjs.org/bare-addon-resolve/-/bare-addon-resolve-1.9.4.tgz",
+      "integrity": "sha512-unn6Vy/Yke6F99vg/7tcrvM2KUvIhTNniaSqDbam4AWkd4NhvDVSrQiRYVlNzUV2P7SPobkCK7JFVxrJk9btCg==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-module-resolve": "^1.10.0",
+        "bare-semver": "^1.0.0"
+      },
+      "peerDependencies": {
+        "bare-url": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-url": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-module-resolve": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/bare-module-resolve/-/bare-module-resolve-1.11.1.tgz",
+      "integrity": "sha512-DCxeT9i8sTs3vUMA3w321OX/oXtNEu5EjObQOnTmCdNp5RXHBAvAaBDHvAi9ta0q/948QPz+co6SsGi6aQMYRg==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-semver": "^1.0.0"
+      },
+      "peerDependencies": {
+        "bare-url": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-url": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-os": {
+      "version": "3.6.1",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.1.tgz",
+      "integrity": "sha512-uaIjxokhFidJP+bmmvKSgiMzj2sV5GPHaZVAIktcxcpCyBFFWO+YlikVAdhmUo2vYFvFhOXIAlldqV29L8126g==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "engines": {
+        "bare": ">=1.14.0"
+      }
+    },
+    "node_modules/bare-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+      "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-os": "^3.0.1"
+      }
+    },
+    "node_modules/bare-semver": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/bare-semver/-/bare-semver-1.0.1.tgz",
+      "integrity": "sha512-UtggzHLiTrmFOC/ogQ+Hy7VfoKoIwrP1UFcYtTxoCUdLtsIErT8+SWtOC2DH/snT9h+xDrcBEPcwKei1mzemgg==",
+      "license": "Apache-2.0",
+      "optional": true
+    },
+    "node_modules/bare-url": {
+      "version": "2.1.6",
+      "resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.1.6.tgz",
+      "integrity": "sha512-FgjDeR+/yDH34By4I0qB5NxAoWv7dOTYcOXwn73kr+c93HyC2lU6tnjifqUe33LKMJcDyCYPQjEAqgOQiXkE2Q==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-path": "^3.0.0"
+      }
+    },
+    "node_modules/base32.js": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/base32.js/-/base32.js-0.1.0.tgz",
+      "integrity": "sha512-n3TkB02ixgBOhTvANakDb4xaMXnYUVkNoRFJjQflcqMQhyEKxEHdj3E6N8t8sUQ0mjH/3/JxzlXuz3ul/J90pQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/bignumber.js": {
+      "version": "9.3.1",
+      "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.1.tgz",
+      "integrity": "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/buffer": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz",
+      "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.2.1"
+      }
+    },
+    "node_modules/call-bind": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
+      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.0",
+        "es-define-property": "^1.0.0",
+        "get-intrinsic": "^1.2.4",
+        "set-function-length": "^1.2.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/commondir": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
+      "integrity": "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/crypto-js": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-4.2.0.tgz",
+      "integrity": "sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==",
+      "license": "MIT"
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/eventsource": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-2.0.2.tgz",
+      "integrity": "sha512-IzUmBGPR3+oUG9dUeXynyNmf91/3zUSJg1lCktzKw47OXuhco54U3r9B7O4XX+Rb1Itm9OZ2b0RkTs10bICOxA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/for-each": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
+      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
+      "license": "MIT",
+      "dependencies": {
+        "is-callable": "^1.2.7"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/glob": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/is-callable": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
+      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.1",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-module": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
+      "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/is-reference": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz",
+      "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "*"
+      }
+    },
+    "node_modules/is-typed-array": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "which-typed-array": "^1.1.16"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/isarray": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
+      "license": "MIT"
+    },
+    "node_modules/jose": {
+      "version": "5.10.0",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-5.10.0.tgz",
+      "integrity": "sha512-s+3Al/p9g32Iq+oqXxkW//7jk2Vig6FF1CFqzVXoTUXt2qz89YWbL+OwS17NFYEvxC35n0FKeGO2LGYSxeM2Gg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.17",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
+      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/possible-typed-array-names": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
+      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/randombytes": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
+      "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "^5.1.0"
+      }
+    },
+    "node_modules/require-addon": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/require-addon/-/require-addon-1.1.0.tgz",
+      "integrity": "sha512-KbXAD5q2+v1GJnkzd8zzbOxchTkStSyJZ9QwoCq3QwEXAaIlG3wDYRZGzVD357jmwaGY7hr5VaoEAL0BkF0Kvg==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-addon-resolve": "^1.3.0",
+        "bare-url": "^2.1.0"
+      },
+      "engines": {
+        "bare": ">=1.10.0"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.10",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
+      "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-core-module": "^2.16.0",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.45.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.45.1.tgz",
+      "integrity": "sha512-4iya7Jb76fVpQyLoiVpzUrsjQ12r3dM7fIVz+4NwoYvZOShknRmiv+iu9CClZml5ZLGb0XMcYLutK6w9tgxHDw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.45.1",
+        "@rollup/rollup-android-arm64": "4.45.1",
+        "@rollup/rollup-darwin-arm64": "4.45.1",
+        "@rollup/rollup-darwin-x64": "4.45.1",
+        "@rollup/rollup-freebsd-arm64": "4.45.1",
+        "@rollup/rollup-freebsd-x64": "4.45.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.45.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.45.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.45.1",
+        "@rollup/rollup-linux-arm64-musl": "4.45.1",
+        "@rollup/rollup-linux-loongarch64-gnu": "4.45.1",
+        "@rollup/rollup-linux-powerpc64le-gnu": "4.45.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.45.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.45.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.45.1",
+        "@rollup/rollup-linux-x64-gnu": "4.45.1",
+        "@rollup/rollup-linux-x64-musl": "4.45.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.45.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.45.1",
+        "@rollup/rollup-win32-x64-msvc": "4.45.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/rollup-plugin-dts": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/rollup-plugin-dts/-/rollup-plugin-dts-6.2.1.tgz",
+      "integrity": "sha512-sR3CxYUl7i2CHa0O7bA45mCrgADyAQ0tVtGSqi3yvH28M+eg1+g5d7kQ9hLvEz5dorK3XVsH5L2jwHLQf72DzA==",
+      "dev": true,
+      "license": "LGPL-3.0-only",
+      "dependencies": {
+        "magic-string": "^0.30.17"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/Swatinem"
+      },
+      "optionalDependencies": {
+        "@babel/code-frame": "^7.26.2"
+      },
+      "peerDependencies": {
+        "rollup": "^3.29.4 || ^4",
+        "typescript": "^4.5 || ^5.0"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/set-function-length": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+      "license": "MIT",
+      "dependencies": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "gopd": "^1.0.1",
+        "has-property-descriptors": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/sha.js": {
+      "version": "2.4.12",
+      "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.12.tgz",
+      "integrity": "sha512-8LzC5+bvI45BjpfXU8V5fdU2mfeKiQe1D1gIMn7XUlF3OTUrpdJpPPH4EMAnF0DsHHdSZqCdSss5qCmJKuiO3w==",
+      "license": "(MIT AND BSD-3-Clause)",
+      "dependencies": {
+        "inherits": "^2.0.4",
+        "safe-buffer": "^5.2.1",
+        "to-buffer": "^1.2.0"
+      },
+      "bin": {
+        "sha.js": "bin.js"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/sodium-native": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/sodium-native/-/sodium-native-4.3.3.tgz",
+      "integrity": "sha512-OnxSlN3uyY8D0EsLHpmm2HOFmKddQVvEMmsakCrXUzSd8kjjbzL413t4ZNF3n0UxSwNgwTyUvkmZHTfuCeiYSw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "require-addon": "^1.1.0"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/to-buffer": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.2.1.tgz",
+      "integrity": "sha512-tB82LpAIWjhLYbqjx3X4zEeHN6M8CiuOEy2JY8SEQVdYRe3CCHOFaqrBW1doLDrfpWhplcW7BL+bO3/6S3pcDQ==",
+      "license": "MIT",
+      "dependencies": {
+        "isarray": "^2.0.5",
+        "safe-buffer": "^5.2.1",
+        "typed-array-buffer": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/toml": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/toml/-/toml-3.0.0.tgz",
+      "integrity": "sha512-y/mWCZinnvxjTKYhJ+pYxwD0mRLVvOtdS2Awbgxln6iEnt4rk0yBxeSBHkGJcPucRiG0e55mwWp+g/05rsrd6w==",
+      "license": "MIT"
+    },
+    "node_modules/tweetnacl": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz",
+      "integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==",
+      "license": "Unlicense"
+    },
+    "node_modules/typed-array-buffer": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
+      "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "is-typed-array": "^1.1.14"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/urijs": {
+      "version": "1.19.11",
+      "resolved": "https://registry.npmjs.org/urijs/-/urijs-1.19.11.tgz",
+      "integrity": "sha512-HXgFDgDommxn5/bIv0cnQZsPhHDA90NPHD6+c/v21U5+Sx5hoP8+dP9IZXBU1gIfvdRfhG8cel9QNPeionfcCQ==",
+      "license": "MIT"
+    },
+    "node_modules/which-typed-array": {
+      "version": "1.1.19",
+      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
+      "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
+      "license": "MIT",
+      "dependencies": {
+        "available-typed-arrays": "^1.0.7",
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.4",
+        "for-each": "^0.3.5",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}
diff --git a/apps/web/stellar-social-sdk/package.json b/apps/web/stellar-social-sdk/package.json
new file mode 100644
index 00000000..230e2b1b
--- /dev/null
+++ b/apps/web/stellar-social-sdk/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "stellar-social-sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Social login SDK for Stellar blockchain",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "test": "node dist/test.js"
+  },
+  "keywords": ["stellar", "social-login", "blockchain", "web3"],
+  "author": "stellar-social-team",
+  "license": "MIT",
+  "dependencies": {
+    "jose": "^5.2.0",
+    "axios": "^1.6.0",
+    "crypto-js": "^4.2.0"
+  },
+  "peerDependencies": {
+    "@stellar/stellar-sdk": "^13.3.0",
+    "@stellar/freighter-api": "^4.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.10.0",
+    "@types/crypto-js": "^4.2.0",
+    "rollup": "^4.0.0",
+    "@rollup/plugin-typescript": "^11.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.0",
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "rollup-plugin-dts": "^6.1.0"
+  }
+}
diff --git a/apps/web/stellar-social-sdk/package.json.backup b/apps/web/stellar-social-sdk/package.json.backup
new file mode 100644
index 00000000..5a10f5c9
--- /dev/null
+++ b/apps/web/stellar-social-sdk/package.json.backup
@@ -0,0 +1,16 @@
+{
+  "name": "stellar-social-sdk",
+  "version": "0.1.0",
+  "description": "Social login SDK for Stellar blockchain",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "test": "node dist/test.js"
+  },
+  "keywords": ["stellar", "social-login", "blockchain", "web3"],
+  "author": "tu-nombre",
+  "license": "MIT"
+}
\ No newline at end of file
diff --git a/apps/web/stellar-social-sdk/rollup.config.js b/apps/web/stellar-social-sdk/rollup.config.js
new file mode 100644
index 00000000..6414f858
--- /dev/null
+++ b/apps/web/stellar-social-sdk/rollup.config.js
@@ -0,0 +1,41 @@
+import typescript from '@rollup/plugin-typescript';
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import dts from 'rollup-plugin-dts';
+
+export default [
+  {
+    input: 'src/index.ts',
+    output: [
+      {
+        file: 'dist/index.js',
+        format: 'cjs',
+        sourcemap: true
+      },
+      {
+        file: 'dist/index.esm.js', 
+        format: 'esm',
+        sourcemap: true
+      }
+    ],
+    plugins: [
+      resolve({
+        browser: true,
+        preferBuiltins: false
+      }),
+      commonjs(),
+      typescript({
+        tsconfig: './tsconfig.json'
+      })
+    ],
+    external: ['@stellar/stellar-sdk']
+  },
+  {
+    input: 'src/index.ts',
+    output: {
+      file: 'dist/index.d.ts',
+      format: 'es'
+    },
+    plugins: [dts()]
+  }
+];
\ No newline at end of file
diff --git a/apps/web/stellar-social-sdk/src/auth/StellarSocialAccount.ts b/apps/web/stellar-social-sdk/src/auth/StellarSocialAccount.ts
new file mode 100644
index 00000000..b52bd73c
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/auth/StellarSocialAccount.ts
@@ -0,0 +1,135 @@
+import { 
+  Keypair, 
+  Horizon, 
+  TransactionBuilder, 
+  Networks, 
+  Operation, 
+  Asset,
+  Memo
+} from '@stellar/stellar-sdk';
+import { AuthMethod, SocialAccountData } from '../types/index.js';
+
+export class StellarSocialAccount {
+  private keypair?: Keypair;
+  private server: Horizon.Server;
+  private contractId: string;
+  private network: string;
+  public data: SocialAccountData;
+
+  constructor(
+    data: SocialAccountData,
+    server: Horizon.Server,
+    contractId: string,
+    network: string,
+    keypair?: Keypair
+  ) {
+    this.data = data;
+    this.server = server;
+    this.contractId = contractId;
+    this.network = network;
+    this.keypair = keypair;
+  }
+
+  get publicKey(): string {
+    return this.data.publicKey;
+  }
+
+  get authMethods(): AuthMethod[] {
+    return this.data.authMethods;
+  }
+
+  /**
+   * Send payment to another account
+   */
+  async sendPayment(
+    destination: string,
+    amount: string,
+    asset: Asset = Asset.native(),
+    memo?: string
+  ): Promise<string> {
+    if (!this.keypair) {
+      throw new Error('No keypair available for signing. Use social auth recovery.');
+    }
+
+    try {
+      const account = await this.server.loadAccount(this.publicKey);
+      
+      const txBuilder = new TransactionBuilder(account, {
+        fee: '100000',
+        networkPassphrase: this.network === 'testnet' ? Networks.TESTNET : Networks.PUBLIC,
+      });
+
+      txBuilder.addOperation(
+        Operation.payment({
+          destination,
+          asset,
+          amount,
+        })
+      );
+
+      if (memo) {
+        // Stellar text memos have a 28-byte limit
+        const truncatedMemo = memo.length > 28 ? memo.substring(0, 28) : memo;
+        txBuilder.addMemo(Memo.text(truncatedMemo));
+      }
+
+      const transaction = txBuilder.setTimeout(300).build();
+      transaction.sign(this.keypair);
+
+      const result = await this.server.submitTransaction(transaction);
+      return result.hash;
+    } catch (error: any) {
+      throw new Error(`Payment failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Add new authentication method - Simplified for MVP
+   */
+  async addAuthMethod(newMethod: AuthMethod): Promise<boolean> {
+    // Para MVP, solo actualizar localmente
+    // En producción, llamar al contrato Soroban
+    this.data.authMethods.push(newMethod);
+    console.log(`✅ Added auth method: ${newMethod.type}`);
+    return true;
+  }
+
+  /**
+   * Get account balance
+   */
+  async getBalance(): Promise<{ balance: string; asset: string }[]> {
+    try {
+      const account = await this.server.loadAccount(this.publicKey);
+      return account.balances.map((balance: any) => ({
+        balance: balance.balance,
+        asset: balance.asset_type === 'native' ? 'XLM' : 
+               `${balance.asset_code}:${balance.asset_issuer}`
+      }));
+    } catch (error: any) {
+      throw new Error(`Failed to get balance: ${error.message}`);
+    }
+  }
+
+  /**
+   * Initialize account with contract (for new accounts)
+   */
+  async initializeWithContract(): Promise<boolean> {
+    if (!this.keypair) {
+      console.log('⚠️ No keypair available, skipping contract initialization');
+      return true; // For MVP, this is OK
+    }
+
+    try {
+      console.log('🔧 Initializing account with social contract...');
+      
+      // For MVP, we'll skip the actual contract call
+      // In production, this would call the contract's initialize function
+      console.log(`✅ Account initialized: ${this.publicKey}`);
+      return true;
+      
+    } catch (error: any) {
+      console.error('Contract initialization failed:', error.message);
+      return false;
+    }
+  }
+}
diff --git a/apps/web/stellar-social-sdk/src/config.ts b/apps/web/stellar-social-sdk/src/config.ts
new file mode 100644
index 00000000..d3896715
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/config.ts
@@ -0,0 +1,3 @@
+export const DEFAULT_CONTRACT_ID = 'CALZGCSB3P3WEBLW3QTF5Y4WEALEVTYUYBC7KBGQ266GDINT7U4E74KW';
+export const TESTNET_HORIZON = 'https://horizon-testnet.stellar.org';
+export const MAINNET_HORIZON = 'https://horizon.stellar.org';
\ No newline at end of file
diff --git a/apps/web/stellar-social-sdk/src/index.ts b/apps/web/stellar-social-sdk/src/index.ts
new file mode 100644
index 00000000..1d76d5af
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/index.ts
@@ -0,0 +1,390 @@
+import { Horizon, Keypair, TransactionBuilder, Networks, Operation } from '@stellar/stellar-sdk';
+import { SocialAuthConfig, AuthMethod, AuthResult, PhoneVerification } from './types/index.js';
+import { StellarSocialAccount } from './auth/StellarSocialAccount.js';
+import { GoogleAuthProvider } from './providers/GoogleAuthProvider.js';
+import { FreighterProvider } from './providers/FreighterProvider.js';
+import { CryptoUtils } from './utils/crypto.js';
+import { DEFAULT_CONTRACT_ID } from './config.js';
+
+export class StellarSocialSDK {
+  private server: Horizon.Server;
+  private contractId: string;
+  private network: string;
+  public googleProvider?: GoogleAuthProvider;
+  private freighterProvider: FreighterProvider;
+
+  constructor(config: SocialAuthConfig) {
+    this.contractId = config.contractId || DEFAULT_CONTRACT_ID;
+    this.network = config.network;
+    this.server = new Horizon.Server(
+      config.horizonUrl || 
+      (config.network === 'testnet' 
+        ? 'https://horizon-testnet.stellar.org'
+        : 'https://horizon.stellar.org')
+    );
+
+    // Initialize providers
+    if (config.googleClientId) {
+      this.googleProvider = new GoogleAuthProvider(config.googleClientId);
+    }
+    this.freighterProvider = new FreighterProvider();
+  }
+
+  /**
+   * Initialize SDK (load external scripts, etc.)
+   */
+  async initialize(): Promise<void> {
+    console.log('🚀 Initializing Stellar Social SDK...');
+    if (this.googleProvider) {
+      await this.googleProvider.initialize();
+    }
+    console.log('✅ SDK initialized');
+  }
+
+  /**
+   * Authenticate with Google using credential response - REAL OAuth
+   */
+  async authenticateWithGoogleCredential(credentialResponse: any): Promise<AuthResult> {
+    try {
+      console.log('🔐 Processing Google credential response...');
+      
+      if (!this.googleProvider) {
+        throw new Error('Google provider not configured. Please provide googleClientId in config.');
+      }
+
+      // Process credential response through provider
+      const authMethod = await this.googleProvider.createAuthMethodFromCredential(credentialResponse);
+      
+      // Use Google sub (user ID) for deterministic keypair generation
+      const googleSub = authMethod.metadata?.sub;
+      if (!googleSub) {
+        throw new Error('Google user ID not found');
+      }
+
+      // Create deterministic keypair from Google user ID
+      const keypair = CryptoUtils.generateKeypair('google', googleSub);
+      const publicKey = keypair.publicKey();
+      
+      console.log(`🔑 Generated deterministic address for Google user: ${publicKey}`);
+      console.log(`👤 Google user: ${authMethod.metadata?.name} (${authMethod.metadata?.email})`);
+
+      // Check if account exists or create new one
+      const account = await this.getOrCreateAccountWithKeypair(keypair, authMethod);
+
+      console.log('✅ Real Google authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Google authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Google authentication failed'
+      };
+    }
+  }
+
+  /**
+   * Authenticate with Google - DEPRECATED, use authenticateWithGoogleCredential
+   */
+  async authenticateWithGoogle(): Promise<AuthResult> {
+    return {
+      success: false,
+      error: 'Direct Google authentication is deprecated. Use authenticateWithGoogleCredential() instead.'
+    };
+  }
+
+  /**
+   * Authenticate with Facebook (mock for MVP)
+   */
+  async authenticateWithFacebook(): Promise<AuthResult> {
+    try {
+      console.log('🔐 Starting Facebook authentication...');
+      
+      const authMethod: AuthMethod = {
+        type: 'facebook',
+        identifier: `user${Math.floor(Math.random() * 1000)}@facebook.com`,
+        token: 'mock_facebook_token',
+        metadata: {
+          name: 'Facebook User',
+          id: 'fb_' + Math.floor(Math.random() * 1000000)
+        }
+      };
+
+      const account = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Facebook authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Facebook authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Facebook authentication failed'
+      };
+    }
+  }
+
+  /**
+   * Authenticate with phone number
+   */
+  async authenticateWithPhone(verification: PhoneVerification): Promise<AuthResult> {
+    try {
+      console.log('📱 Starting phone authentication...');
+      
+      if (verification.verificationCode !== '123456') {
+        throw new Error('Invalid verification code. Use 123456 for testing');
+      }
+
+      const authMethod: AuthMethod = {
+        type: 'phone',
+        identifier: CryptoUtils.hashPhone(verification.phoneNumber),
+        metadata: {
+          phoneNumber: verification.phoneNumber
+        }
+      };
+
+      const account = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Phone authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Phone authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Phone authentication failed'
+      };
+    }
+  }
+
+  /**
+   * Connect Freighter wallet
+   */
+  async connectFreighter(): Promise<AuthResult> {
+    try {
+      console.log('🦊 Connecting to Freighter wallet...');
+      
+      const authMethod = await this.freighterProvider.connect();
+      const account = await this.loadExistingAccount(authMethod.identifier);
+      
+      if (account) {
+        console.log('✅ Connected to existing Freighter account');
+        return {
+          success: true,
+          account
+        };
+      }
+
+      const newAccount = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Freighter wallet connected');
+      return {
+        success: true,
+        account: newAccount
+      };
+    } catch (error: any) {
+      console.error('❌ Freighter connection failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Freighter connection failed'
+      };
+    }
+  }
+
+  /**
+   * Get or create account for auth method
+   */
+  private async getOrCreateAccount(authMethod: AuthMethod): Promise<StellarSocialAccount> {
+    let keypair: Keypair;
+
+    if (authMethod.type === 'freighter') {
+      keypair = Keypair.fromPublicKey(authMethod.identifier);
+    } else {
+      keypair = CryptoUtils.generateKeypair(authMethod.type, authMethod.identifier);
+    }
+
+    const publicKey = keypair.publicKey();
+    console.log(`🔑 Generated address: ${publicKey}`);
+
+    try {
+      await this.server.loadAccount(publicKey);
+      console.log('📋 Loading existing account:', publicKey);
+      
+      const accountData = {
+        publicKey,
+        authMethods: [authMethod],
+        createdAt: Date.now(),
+        recoveryContacts: []
+      };
+
+      return new StellarSocialAccount(
+        accountData,
+        this.server,
+        this.contractId,
+        this.network,
+        authMethod.type !== 'freighter' ? keypair : undefined
+      );
+
+    } catch (error) {
+      console.log('🔨 Creating new account for:', authMethod.type);
+      return await this.createNewAccount(keypair, authMethod);
+    }
+  }
+
+  /**
+   * Get or create account with specific keypair
+   */
+  private async getOrCreateAccountWithKeypair(
+    keypair: Keypair, 
+    authMethod: AuthMethod
+  ): Promise<StellarSocialAccount> {
+    const publicKey = keypair.publicKey();
+
+    try {
+      await this.server.loadAccount(publicKey);
+      console.log('📋 Loading existing account:', publicKey);
+      
+      const accountData = {
+        publicKey,
+        authMethods: [authMethod],
+        createdAt: Date.now(),
+        recoveryContacts: []
+      };
+
+      return new StellarSocialAccount(
+        accountData,
+        this.server,
+        this.contractId,
+        this.network,
+        keypair
+      );
+
+    } catch (error) {
+      console.log('🔨 Creating new account for Google user:', authMethod.metadata?.email);
+      return await this.createNewAccountWithKeypair(keypair, authMethod);
+    }
+  }
+
+  /**
+   * Create new Stellar account
+   */
+  private async createNewAccount(
+    keypair: Keypair, 
+    authMethod: AuthMethod
+  ): Promise<StellarSocialAccount> {
+    const publicKey = keypair.publicKey();
+
+    if (this.network === 'testnet') {
+      console.log('💰 Funding testnet account...');
+      await this.fundTestnetAccount(publicKey);
+      console.log('⏳ Waiting for account creation...');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+
+    const accountData = {
+      publicKey,
+      authMethods: [authMethod],
+      createdAt: Date.now(),
+      recoveryContacts: []
+    };
+
+    const account = new StellarSocialAccount(
+      accountData,
+      this.server,
+      this.contractId,
+      this.network,
+      authMethod.type !== 'freighter' ? keypair : undefined
+    );
+
+    await account.initializeWithContract();
+    return account;
+  }
+
+  /**
+   * Create new account with specific keypair
+   */
+  private async createNewAccountWithKeypair(
+    keypair: Keypair, 
+    authMethod: AuthMethod
+  ): Promise<StellarSocialAccount> {
+    const publicKey = keypair.publicKey();
+
+    if (this.network === 'testnet') {
+      console.log('💰 Funding testnet account...');
+      await this.fundTestnetAccount(publicKey);
+      console.log('⏳ Waiting for account creation...');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+
+    const accountData = {
+      publicKey,
+      authMethods: [authMethod],
+      createdAt: Date.now(),
+      recoveryContacts: []
+    };
+
+    const account = new StellarSocialAccount(
+      accountData,
+      this.server,
+      this.contractId,
+      this.network,
+      keypair
+    );
+
+    await account.initializeWithContract();
+    return account;
+  }
+
+  /**
+   * Fund testnet account using friendbot
+   */
+  private async fundTestnetAccount(publicKey: string): Promise<void> {
+    if (this.network !== 'testnet') return;
+
+    try {
+      const response = await fetch(`https://friendbot.stellar.org?addr=${publicKey}`);
+      if (!response.ok) {
+        throw new Error('Friendbot funding failed');
+      }
+      console.log('✅ Account funded with testnet XLM');
+    } catch (error: any) {
+      console.warn('⚠️ Friendbot funding failed:', error.message);
+    }
+  }
+
+  /**
+   * Load existing account if it exists
+   */
+  private async loadExistingAccount(publicKey: string): Promise<StellarSocialAccount | null> {
+    try {
+      await this.server.loadAccount(publicKey);
+      
+      const accountData = {
+        publicKey,
+        authMethods: [],
+        createdAt: Date.now(),
+        recoveryContacts: []
+      };
+
+      return new StellarSocialAccount(
+        accountData,
+        this.server,
+        this.contractId,
+        this.network
+      );
+    } catch (error) {
+      return null;
+    }
+  }
+}
+
+// Export all types and classes
+export * from './types/index.js';
+export { StellarSocialAccount } from './auth/StellarSocialAccount.js';
+export { DEFAULT_CONTRACT_ID } from './config.js';
diff --git a/apps/web/stellar-social-sdk/src/index.ts.backup b/apps/web/stellar-social-sdk/src/index.ts.backup
new file mode 100644
index 00000000..a1f02a02
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/index.ts.backup
@@ -0,0 +1,299 @@
+import { Horizon, Keypair, TransactionBuilder, Networks, Operation } from '@stellar/stellar-sdk';
+import { SocialAuthConfig, AuthMethod, AuthResult, PhoneVerification } from './types/index.js';
+import { StellarSocialAccount } from './auth/StellarSocialAccount.js';
+import { GoogleAuthProvider } from './providers/GoogleAuthProvider.js';
+import { FreighterProvider } from './providers/FreighterProvider.js';
+import { CryptoUtils } from './utils/crypto.js';
+import { DEFAULT_CONTRACT_ID } from './config.js';
+
+export class StellarSocialSDK {
+  private server: Horizon.Server;
+  private contractId: string;
+  private network: string;
+  private googleProvider?: GoogleAuthProvider;
+  private freighterProvider: FreighterProvider;
+
+  constructor(config: SocialAuthConfig) {
+    this.contractId = config.contractId || DEFAULT_CONTRACT_ID;
+    this.network = config.network;
+    this.server = new Horizon.Server(
+      config.horizonUrl || 
+      (config.network === 'testnet' 
+        ? 'https://horizon-testnet.stellar.org'
+        : 'https://horizon.stellar.org')
+    );
+
+    // Initialize providers
+    this.googleProvider = new GoogleAuthProvider(config.googleClientId);
+    this.freighterProvider = new FreighterProvider();
+  }
+
+  /**
+   * Initialize SDK (load external scripts, etc.)
+   */
+  async initialize(): Promise<void> {
+    console.log('🚀 Initializing Stellar Social SDK...');
+    if (this.googleProvider) {
+      await this.googleProvider.initialize();
+    }
+    console.log('✅ SDK initialized');
+  }
+
+  /**
+   * Authenticate with Google
+   */
+  async authenticateWithGoogle(): Promise<AuthResult> {
+    try {
+      console.log('🔐 Starting Google authentication...');
+      
+      if (!this.googleProvider) {
+        throw new Error('Google provider not configured');
+      }
+
+      const authMethod = await this.googleProvider.authenticate();
+      const account = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Google authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Google authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Google authentication failed'
+      };
+    }
+  }
+
+  /**
+   * Authenticate with Facebook (mock for MVP)
+   */
+  async authenticateWithFacebook(): Promise<AuthResult> {
+    try {
+      console.log('🔐 Starting Facebook authentication...');
+      
+      const authMethod: AuthMethod = {
+        type: 'facebook',
+        identifier: `user${Math.floor(Math.random() * 1000)}@facebook.com`,
+        token: 'mock_facebook_token',
+        metadata: {
+          name: 'Facebook User',
+          id: 'fb_' + Math.floor(Math.random() * 1000000)
+        }
+      };
+
+      const account = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Facebook authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Facebook authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Facebook authentication failed'
+      };
+    }
+  }
+
+  /**
+   * Authenticate with phone number
+   */
+  async authenticateWithPhone(verification: PhoneVerification): Promise<AuthResult> {
+    try {
+      console.log('📱 Starting phone authentication...');
+      
+      if (verification.verificationCode !== '123456') {
+        throw new Error('Invalid verification code. Use 123456 for testing');
+      }
+
+      const authMethod: AuthMethod = {
+        type: 'phone',
+        identifier: CryptoUtils.hashPhone(verification.phoneNumber),
+        metadata: {
+          phoneNumber: verification.phoneNumber
+        }
+      };
+
+      const account = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Phone authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Phone authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Phone authentication failed'
+      };
+    }
+  }
+
+  /**
+   * Connect Freighter wallet
+   */
+  async connectFreighter(): Promise<AuthResult> {
+    try {
+      console.log('🦊 Connecting to Freighter wallet...');
+      
+      const authMethod = await this.freighterProvider.connect();
+      const account = await this.loadExistingAccount(authMethod.identifier);
+      
+      if (account) {
+        console.log('✅ Connected to existing Freighter account');
+        return {
+          success: true,
+          account
+        };
+      }
+
+      const newAccount = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Freighter wallet connected');
+      return {
+        success: true,
+        account: newAccount
+      };
+    } catch (error: any) {
+      console.error('❌ Freighter connection failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Freighter connection failed'
+      };
+    }
+  }
+
+  /**
+   * Get or create account for auth method
+   */
+  private async getOrCreateAccount(authMethod: AuthMethod): Promise<StellarSocialAccount> {
+    let keypair: Keypair;
+
+    if (authMethod.type === 'freighter') {
+      // For Freighter, use the existing public key
+      keypair = Keypair.fromPublicKey(authMethod.identifier);
+    } else {
+      // For social auth, generate deterministic keypair
+      keypair = CryptoUtils.generateKeypair(authMethod.type, authMethod.identifier);
+    }
+
+    const publicKey = keypair.publicKey();
+    console.log(`🔑 Generated address: ${publicKey}`);
+
+    try {
+      // Check if account exists on blockchain
+      await this.server.loadAccount(publicKey);
+      console.log('📋 Loading existing account:', publicKey);
+      
+      const accountData = {
+        publicKey,
+        authMethods: [authMethod],
+        createdAt: Date.now(),
+        recoveryContacts: []
+      };
+
+      return new StellarSocialAccount(
+        accountData,
+        this.server,
+        this.contractId,
+        this.network,
+        authMethod.type !== 'freighter' ? keypair : undefined
+      );
+
+    } catch (error) {
+      // Account doesn't exist, create it
+      console.log('🔨 Creating new account for:', authMethod.type);
+      return await this.createNewAccount(keypair, authMethod);
+    }
+  }
+
+  /**
+   * Create new Stellar account
+   */
+  private async createNewAccount(
+    keypair: Keypair, 
+    authMethod: AuthMethod
+  ): Promise<StellarSocialAccount> {
+    const publicKey = keypair.publicKey();
+
+    if (this.network === 'testnet') {
+      console.log('💰 Funding testnet account...');
+      await this.fundTestnetAccount(publicKey);
+      console.log('⏳ Waiting for account creation...');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+
+    const accountData = {
+      publicKey,
+      authMethods: [authMethod],
+      createdAt: Date.now(),
+      recoveryContacts: []
+    };
+
+    const account = new StellarSocialAccount(
+      accountData,
+      this.server,
+      this.contractId,
+      this.network,
+      authMethod.type !== 'freighter' ? keypair : undefined
+    );
+
+    // Initialize with contract
+    await account.initializeWithContract();
+
+    return account;
+  }
+
+  /**
+   * Fund testnet account using friendbot
+   */
+  private async fundTestnetAccount(publicKey: string): Promise<void> {
+    if (this.network !== 'testnet') return;
+
+    try {
+      const response = await fetch(`https://friendbot.stellar.org?addr=${publicKey}`);
+      if (!response.ok) {
+        throw new Error('Friendbot funding failed');
+      }
+      console.log('✅ Account funded with testnet XLM');
+    } catch (error: any) {
+      console.warn('⚠️ Friendbot funding failed:', error.message);
+    }
+  }
+
+  /**
+   * Load existing account if it exists
+   */
+  private async loadExistingAccount(publicKey: string): Promise<StellarSocialAccount | null> {
+    try {
+      await this.server.loadAccount(publicKey);
+      
+      const accountData = {
+        publicKey,
+        authMethods: [],
+        createdAt: Date.now(),
+        recoveryContacts: []
+      };
+
+      return new StellarSocialAccount(
+        accountData,
+        this.server,
+        this.contractId,
+        this.network
+      );
+    } catch (error) {
+      return null;
+    }
+  }
+}
+
+// Export all types and classes
+export * from './types/index.js';
+export { StellarSocialAccount } from './auth/StellarSocialAccount.js';
+export { DEFAULT_CONTRACT_ID } from './config.js';
diff --git a/apps/web/stellar-social-sdk/src/index.ts.corrupted b/apps/web/stellar-social-sdk/src/index.ts.corrupted
new file mode 100644
index 00000000..0ddb5186
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/index.ts.corrupted
@@ -0,0 +1,390 @@
+import { Horizon, Keypair, TransactionBuilder, Networks, Operation } from '@stellar/stellar-sdk';
+import { SocialAuthConfig, AuthMethod, AuthResult, PhoneVerification } from './types/index.js';
+import { StellarSocialAccount } from './auth/StellarSocialAccount.js';
+import { GoogleAuthProvider } from './providers/GoogleAuthProvider.js';
+import { FreighterProvider } from './providers/FreighterProvider.js';
+import { CryptoUtils } from './utils/crypto.js';
+import { DEFAULT_CONTRACT_ID } from './config.js';
+
+export class StellarSocialSDK {
+  private server: Horizon.Server;
+  private contractId: string;
+  private network: string;
+  private googleProvider?: GoogleAuthProvider;
+  private freighterProvider: FreighterProvider;
+
+  constructor(config: SocialAuthConfig) {
+    this.contractId = config.contractId || DEFAULT_CONTRACT_ID;
+    this.network = config.network;
+    this.server = new Horizon.Server(
+      config.horizonUrl || 
+      (config.network === 'testnet' 
+        ? 'https://horizon-testnet.stellar.org'
+        : 'https://horizon.stellar.org')
+    );
+
+    // Initialize providers
+    this.googleProvider = new GoogleAuthProvider(config.googleClientId);
+    this.freighterProvider = new FreighterProvider();
+  }
+
+  /**
+   * Initialize SDK (load external scripts, etc.)
+   */
+  async initialize(): Promise<void> {
+    console.log('🚀 Initializing Stellar Social SDK...');
+    if (this.googleProvider) {
+      await this.googleProvider.initialize();
+    }
+    console.log('✅ SDK initialized');
+  }
+
+  /**
+   * Authenticate with Google
+   */
+  /**
+   * Authenticate with Google - REAL OAuth
+   */
+  async authenticateWithGoogle(): Promise<AuthResult> {
+    try {
+      console.log('🔐 Starting real Google authentication...');
+      
+      if (!this.googleProvider) {
+        throw new Error('Google provider not configured');
+      }
+
+      // Real Google OAuth flow
+      const authMethod = await this.googleProvider.authenticate();
+      
+      // Use Google sub (user ID) for deterministic keypair generation
+      const googleSub = authMethod.metadata?.sub;
+      if (!googleSub) {
+        throw new Error('Google user ID not found');
+      }
+
+      // Create deterministic keypair from Google user ID
+      const keypair = CryptoUtils.generateKeypair('google', googleSub);
+      const publicKey = keypair.publicKey();
+      
+      console.log(`🔑 Generated deterministic address for Google user: ${publicKey}`);
+      console.log(`👤 Google user: ${authMethod.metadata?.name} (${authMethod.metadata?.email})`);
+
+      // Check if account exists or create new one
+      const account = await this.getOrCreateAccountWithKeypair(keypair, authMethod);
+
+      console.log('✅ Real Google authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Google authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Google authentication failed'
+      };
+    }
+  }
+  /**
+   * Authenticate with Facebook (mock for MVP)
+   */
+  async authenticateWithFacebook(): Promise<AuthResult> {
+    try {
+      console.log('🔐 Starting Facebook authentication...');
+      
+      const authMethod: AuthMethod = {
+        type: 'facebook',
+        identifier: `user${Math.floor(Math.random() * 1000)}@facebook.com`,
+        token: 'mock_facebook_token',
+        metadata: {
+          name: 'Facebook User',
+          id: 'fb_' + Math.floor(Math.random() * 1000000)
+        }
+      };
+
+      const account = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Facebook authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Facebook authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Facebook authentication failed'
+      };
+    }
+  }
+
+  /**
+   * Authenticate with phone number
+   */
+  async authenticateWithPhone(verification: PhoneVerification): Promise<AuthResult> {
+    try {
+      console.log('📱 Starting phone authentication...');
+      
+      if (verification.verificationCode !== '123456') {
+        throw new Error('Invalid verification code. Use 123456 for testing');
+      }
+
+      const authMethod: AuthMethod = {
+        type: 'phone',
+        identifier: CryptoUtils.hashPhone(verification.phoneNumber),
+        metadata: {
+          phoneNumber: verification.phoneNumber
+        }
+      };
+
+      const account = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Phone authentication successful');
+      return {
+        success: true,
+        account
+      };
+    } catch (error: any) {
+      console.error('❌ Phone authentication failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Phone authentication failed'
+      };
+    }
+  }
+
+  /**
+   * Connect Freighter wallet
+   */
+  async connectFreighter(): Promise<AuthResult> {
+    try {
+      console.log('🦊 Connecting to Freighter wallet...');
+      
+      const authMethod = await this.freighterProvider.connect();
+      const account = await this.loadExistingAccount(authMethod.identifier);
+      
+      if (account) {
+        console.log('✅ Connected to existing Freighter account');
+        return {
+          success: true,
+          account
+        };
+      }
+
+      const newAccount = await this.getOrCreateAccount(authMethod);
+
+      console.log('✅ Freighter wallet connected');
+      return {
+        success: true,
+        account: newAccount
+      };
+    } catch (error: any) {
+      console.error('❌ Freighter connection failed:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Freighter connection failed'
+      };
+    }
+  }
+
+  /**
+   * Get or create account for auth method
+   */
+  private async getOrCreateAccount(authMethod: AuthMethod): Promise<StellarSocialAccount> {
+    let keypair: Keypair;
+
+    if (authMethod.type === 'freighter') {
+      // For Freighter, use the existing public key
+      keypair = Keypair.fromPublicKey(authMethod.identifier);
+    } else {
+      // For social auth, generate deterministic keypair
+      keypair = CryptoUtils.generateKeypair(authMethod.type, authMethod.identifier);
+    }
+
+    const publicKey = keypair.publicKey();
+    console.log(`🔑 Generated address: ${publicKey}`);
+
+    try {
+      // Check if account exists on blockchain
+      await this.server.loadAccount(publicKey);
+      console.log('📋 Loading existing account:', publicKey);
+      
+      const accountData = {
+        publicKey,
+        authMethods: [authMethod],
+        createdAt: Date.now(),
+        recoveryContacts: []
+      };
+
+      return new StellarSocialAccount(
+        accountData,
+        this.server,
+        this.contractId,
+        this.network,
+        authMethod.type !== 'freighter' ? keypair : undefined
+      );
+
+    } catch (error) {
+      // Account doesn't exist, create it
+      console.log('🔨 Creating new account for:', authMethod.type);
+      return await this.createNewAccount(keypair, authMethod);
+    }
+  }
+
+  /**
+   * Create new Stellar account
+   */
+  private async createNewAccount(
+    keypair: Keypair, 
+    authMethod: AuthMethod
+  ): Promise<StellarSocialAccount> {
+    const publicKey = keypair.publicKey();
+
+    if (this.network === 'testnet') {
+      console.log('💰 Funding testnet account...');
+      await this.fundTestnetAccount(publicKey);
+      console.log('⏳ Waiting for account creation...');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+
+    const accountData = {
+      publicKey,
+      authMethods: [authMethod],
+      createdAt: Date.now(),
+      recoveryContacts: []
+    };
+
+    const account = new StellarSocialAccount(
+      accountData,
+      this.server,
+      this.contractId,
+      this.network,
+      authMethod.type !== 'freighter' ? keypair : undefined
+    );
+
+    // Initialize with contract
+    await account.initializeWithContract();
+
+    return account;
+  }
+
+  /**
+   * Fund testnet account using friendbot
+   */
+  private async fundTestnetAccount(publicKey: string): Promise<void> {
+    if (this.network !== 'testnet') return;
+
+    try {
+      const response = await fetch(`https://friendbot.stellar.org?addr=${publicKey}`);
+      if (!response.ok) {
+        throw new Error('Friendbot funding failed');
+      }
+      console.log('✅ Account funded with testnet XLM');
+    } catch (error: any) {
+      console.warn('⚠️ Friendbot funding failed:', error.message);
+    }
+  }
+
+  /**
+   * Load existing account if it exists
+   */
+  private async loadExistingAccount(publicKey: string): Promise<StellarSocialAccount | null> {
+    try {
+      await this.server.loadAccount(publicKey);
+      
+      const accountData = {
+        publicKey,
+        authMethods: [],
+        createdAt: Date.now(),
+        recoveryContacts: []
+      };
+
+      return new StellarSocialAccount(
+        accountData,
+        this.server,
+        this.contractId,
+        this.network
+      );
+    } catch (error) {
+      return null;
+    }
+  }
+}
+
+// Export all types and classes
+export * from './types/index.js';
+export { StellarSocialAccount } from './auth/StellarSocialAccount.js';
+export { DEFAULT_CONTRACT_ID } from './config.js';
+
+  /**
+   * Get or create account with specific keypair
+   */
+  private async getOrCreateAccountWithKeypair(
+    keypair: Keypair, 
+    authMethod: AuthMethod
+  ): Promise<StellarSocialAccount> {
+    const publicKey = keypair.publicKey();
+
+    try {
+      // Check if account exists on blockchain
+      await this.server.loadAccount(publicKey);
+      console.log('📋 Loading existing account:', publicKey);
+      
+      const accountData = {
+        publicKey,
+        authMethods: [authMethod],
+        createdAt: Date.now(),
+        recoveryContacts: []
+      };
+
+      return new StellarSocialAccount(
+        accountData,
+        this.server,
+        this.contractId,
+        this.network,
+        keypair
+      );
+
+    } catch (error) {
+      // Account doesn't exist, create it
+      console.log('🔨 Creating new account for Google user:', authMethod.metadata?.email);
+      return await this.createNewAccountWithKeypair(keypair, authMethod);
+    }
+  }
+
+  /**
+   * Create new account with specific keypair
+   */
+  private async createNewAccountWithKeypair(
+    keypair: Keypair, 
+    authMethod: AuthMethod
+  ): Promise<StellarSocialAccount> {
+    const publicKey = keypair.publicKey();
+
+    if (this.network === 'testnet') {
+      console.log('💰 Funding testnet account...');
+      await this.fundTestnetAccount(publicKey);
+      console.log('⏳ Waiting for account creation...');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+
+    const accountData = {
+      publicKey,
+      authMethods: [authMethod],
+      createdAt: Date.now(),
+      recoveryContacts: []
+    };
+
+    const account = new StellarSocialAccount(
+      accountData,
+      this.server,
+      this.contractId,
+      this.network,
+      keypair
+    );
+
+    // Initialize with contract
+    await account.initializeWithContract();
+
+    return account;
+  }
diff --git a/apps/web/stellar-social-sdk/src/providers/FreighterProvider.ts b/apps/web/stellar-social-sdk/src/providers/FreighterProvider.ts
new file mode 100644
index 00000000..e54dc9c4
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/providers/FreighterProvider.ts
@@ -0,0 +1,83 @@
+import {
+  isConnected,
+  requestAccess,
+  getNetwork,
+  signTransaction,
+} from '@stellar/freighter-api';
+import { AuthMethod } from '../types';
+
+export class FreighterProvider {
+  /**
+   * Check if Freighter is installed
+   */
+  async isInstalled(): Promise<boolean> {
+    try {
+      const result = await isConnected();
+      // Handle both old and new API response formats
+      return typeof result === 'boolean' ? result : result.isConnected;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Connect to Freighter wallet
+   */
+  async connect(): Promise<AuthMethod> {
+    const installed = await this.isInstalled();
+    if (!installed) {
+      throw new Error('Freighter wallet not installed. Please install from https://freighter.app');
+    }
+
+    try {
+      const accessResult = await requestAccess();
+      // Handle both old and new API response formats
+      const publicKey = typeof accessResult === 'string'
+        ? accessResult
+        : accessResult.address;
+
+      if (!publicKey) {
+        throw new Error('User denied access or no public key returned');
+      }
+
+      return {
+        type: 'freighter',
+        identifier: publicKey,
+        metadata: {
+          walletType: 'freighter',
+          connected: true
+        }
+      };
+    } catch (error) {
+      throw new Error(`Failed to connect to Freighter: ${error}`);
+    }
+  }
+
+  /**
+   * Get current network from Freighter
+   */
+  async getNetworkName(): Promise<string> {
+    const installed = await this.isInstalled();
+    if (!installed) {
+      throw new Error('Freighter not installed');
+    }
+
+    const result = await getNetwork();
+    // Handle both old and new API response formats
+    return typeof result === 'string' ? result : result.network;
+  }
+
+  /**
+   * Sign transaction with Freighter
+   */
+  async signTx(transaction: string, opts?: { network?: string; networkPassphrase?: string }): Promise<string> {
+    const installed = await this.isInstalled();
+    if (!installed) {
+      throw new Error('Freighter not installed');
+    }
+
+    const result = await signTransaction(transaction, opts);
+    // Handle both old and new API response formats
+    return typeof result === 'string' ? result : result.signedTxXdr;
+  }
+}
\ No newline at end of file
diff --git a/apps/web/stellar-social-sdk/src/providers/GoogleAuthProvider.ts b/apps/web/stellar-social-sdk/src/providers/GoogleAuthProvider.ts
new file mode 100644
index 00000000..07470f27
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/providers/GoogleAuthProvider.ts
@@ -0,0 +1,204 @@
+import { AuthMethod } from '../types/index.js';
+import { CryptoUtils } from '../utils/crypto.js';
+
+declare global {
+  interface Window {
+    google?: {
+      accounts: {
+        id: {
+          initialize: (config: any) => void;
+          prompt: () => void;
+          renderButton: (element: Element, config: any) => void;
+        };
+      };
+    };
+    handleGoogleCredential?: (response: any) => void;
+  }
+}
+
+export class GoogleAuthProvider {
+  private clientId: string;
+  private initialized = false;
+
+  constructor(clientId: string) {
+    if (!clientId) {
+      throw new Error('Google Client ID is required');
+    }
+    this.clientId = clientId;
+  }
+
+  /**
+   * Initialize Google Identity Services (only load script, don't initialize)
+   */
+  async initialize(): Promise<void> {
+    if (typeof window === 'undefined') return;
+    if (this.initialized) return;
+    
+    console.log('🔧 Loading Google Identity Services script...');
+    
+    // Only load the script, let the demo app handle initialization
+    await this.loadGoogleIdentityServices();
+    
+    this.initialized = true;
+    console.log('✅ Google Identity Services script loaded');
+  }
+
+  /**
+   * Load Google Identity Services script
+   */
+  private loadGoogleIdentityServices(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (document.querySelector('script[src="https://accounts.google.com/gsi/client"]')) {
+        resolve();
+        return;
+      }
+
+      const script = document.createElement('script');
+      script.src = 'https://accounts.google.com/gsi/client';
+      script.async = true;
+      script.defer = true;
+      
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error('Failed to load Google Identity Services'));
+      
+      document.head.appendChild(script);
+    });
+  }
+
+  /**
+   * Handle Google credential response
+   */
+  private handleCredentialResponse(response: any) {
+    if (window.handleGoogleCredential) {
+      window.handleGoogleCredential(response);
+    }
+  }
+
+  /**
+   * Create AuthMethod from Google credential response
+   */
+  async createAuthMethodFromCredential(credentialResponse: any): Promise<AuthMethod> {
+    try {
+      const userInfo = await this.verifyToken(credentialResponse.credential);
+      
+      const authMethod: AuthMethod = {
+        type: 'google',
+        identifier: userInfo.email,
+        token: credentialResponse.credential,
+        metadata: {
+          name: userInfo.name,
+          picture: userInfo.picture,
+          sub: userInfo.sub,
+          email: userInfo.email,
+          email_verified: userInfo.email_verified,
+        }
+      };
+
+      console.log('✅ Google authentication successful:', userInfo.email);
+      return authMethod;
+    } catch (error: any) {
+      console.error('❌ Google authentication failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Authenticate with Google - Real OAuth flow (deprecated, use createAuthMethodFromCredential)
+   */
+  async authenticate(): Promise<AuthMethod> {
+    throw new Error('Direct authenticate() is deprecated. Use createAuthMethodFromCredential() instead.');
+  }
+
+  /**
+   * Render Google Sign-In button
+   */
+  renderButton(element: Element, config: any = {}): void {
+    if (!this.initialized || !window.google?.accounts?.id) {
+      throw new Error('Google Identity Services not initialized');
+    }
+
+    const defaultConfig = {
+      type: 'standard',
+      shape: 'rectangular',
+      theme: 'outline',
+      text: 'signin_with',
+      size: 'large',
+      logo_alignment: 'left',
+      width: '100%',
+    };
+
+    window.google.accounts.id.renderButton(element, { ...defaultConfig, ...config });
+  }
+
+  /**
+   * Verify Google JWT token with enhanced validation
+   */
+  async verifyToken(token: string): Promise<any> {
+    try {
+      // Decode JWT without verification (for demo purposes)
+      // In production, verify signature with Google's public keys
+      const payload = this.decodeJWT(token);
+      
+      // Basic validation
+      if (!payload.iss || (payload.iss !== 'https://accounts.google.com' && payload.iss !== 'accounts.google.com')) {
+        throw new Error(`Invalid token issuer: ${payload.iss}`);
+      }
+      
+      if (!payload.aud || payload.aud !== this.clientId) {
+        throw new Error(`Invalid token audience. Expected: ${this.clientId}, Got: ${payload.aud}`);
+      }
+      
+      if (!payload.exp || payload.exp < Date.now() / 1000) {
+        throw new Error('Token expired');
+      }
+
+      if (!payload.sub) {
+        throw new Error('Missing user ID in token');
+      }
+
+      if (!payload.email) {
+        throw new Error('Missing email in token');
+      }
+
+      return payload;
+    } catch (error: any) {
+      throw new Error(`Token verification failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Decode JWT token (basic decoding)
+   */
+  private decodeJWT(token: string): any {
+    try {
+      const parts = token.split('.');
+      if (parts.length !== 3) {
+        throw new Error('Invalid JWT format');
+      }
+
+      const payload = parts[1];
+      const decoded = atob(payload.replace(/-/g, '+').replace(/_/g, '/'));
+      return JSON.parse(decoded);
+    } catch (error) {
+      throw new Error('Failed to decode JWT');
+    }
+  }
+
+  /**
+   * Generate deterministic seed from Google user ID
+   */
+  generateSeed(googleSub: string): string {
+    return CryptoUtils.generateSeed('google', googleSub);
+  }
+
+  /**
+   * Sign out from Google
+   */
+  signOut(): void {
+    if (window.google?.accounts?.id) {
+      // Google Identity Services doesn't have direct sign out
+      // We'll handle this in the app level
+      console.log('Google sign out requested');
+    }
+  }
+}
diff --git a/apps/web/stellar-social-sdk/src/types/index.ts b/apps/web/stellar-social-sdk/src/types/index.ts
new file mode 100644
index 00000000..a28f96f3
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/types/index.ts
@@ -0,0 +1,43 @@
+export interface SocialAuthConfig {
+  contractId: string;
+  network: 'testnet' | 'mainnet';
+  horizonUrl?: string;
+  googleClientId?: string;
+  facebookAppId?: string;
+}
+
+export interface AuthMethod {
+  type: 'google' | 'facebook' | 'phone' | 'passkey' | 'freighter';
+  identifier: string;
+  token?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface SocialAccountData {
+  publicKey: string;
+  authMethods: AuthMethod[];
+  createdAt: number;
+  recoveryContacts: string[];
+}
+
+export interface AuthResult {
+  success: boolean;
+  account?: any; // We'll import StellarSocialAccount in index.ts to avoid circular dependency
+  error?: string;
+}
+
+export interface PhoneVerification {
+  phoneNumber: string;
+  verificationCode: string;
+}
+
+// Freighter wallet interface
+declare global {
+  interface Window {
+    freighter?: {
+      requestAccess(): Promise<{ publicKey: string }>;
+      signTransaction(txn: string, network: string): Promise<{ signedTxn: string }>;
+      getNetwork(): Promise<{ network: string; networkPassphrase: string }>;
+    };
+  }
+}
diff --git a/apps/web/stellar-social-sdk/src/utils/crypto.ts b/apps/web/stellar-social-sdk/src/utils/crypto.ts
new file mode 100644
index 00000000..f5af872a
--- /dev/null
+++ b/apps/web/stellar-social-sdk/src/utils/crypto.ts
@@ -0,0 +1,60 @@
+import CryptoJS from 'crypto-js';
+import { Keypair } from '@stellar/stellar-sdk';
+
+export class CryptoUtils {
+  /**
+   * Generate deterministic Stellar keypair from provider and identifier
+   */
+  static generateKeypair(provider: string, identifier: string, salt: string = 'stellar-social-v1'): Keypair {
+    // Generate a deterministic seed
+    const combined = `${provider}:${identifier}:${salt}`;
+    const hash = CryptoJS.SHA256(combined);
+    
+    // Convert to bytes and use for keypair generation
+    const seedBytes = new Uint8Array(32);
+    const hashWords = hash.words;
+    
+    for (let i = 0; i < 8; i++) {
+      const word = hashWords[i];
+      seedBytes[i * 4] = (word >>> 24) & 0xff;
+      seedBytes[i * 4 + 1] = (word >>> 16) & 0xff;
+      seedBytes[i * 4 + 2] = (word >>> 8) & 0xff;
+      seedBytes[i * 4 + 3] = word & 0xff;
+    }
+    
+    // Generate keypair from the seed
+    return Keypair.fromRawEd25519Seed(Buffer.from(seedBytes));
+  }
+
+  /**
+   * Generate deterministic seed string (legacy method)
+   */
+  static generateSeed(provider: string, identifier: string, salt: string = 'stellar-social-v1'): string {
+    const combined = `${provider}:${identifier}:${salt}`;
+    return CryptoJS.SHA256(combined).toString(CryptoJS.enc.Hex);
+  }
+
+  /**
+   * Verify JWT token structure (basic validation)
+   */
+  static isValidJWT(token: string): boolean {
+    const parts = token.split('.');
+    return parts.length === 3;
+  }
+
+  /**
+   * Hash phone number for privacy
+   */
+  static hashPhone(phoneNumber: string): string {
+    // Remove non-digits and hash
+    const cleaned = phoneNumber.replace(/\D/g, '');
+    return CryptoJS.SHA256(cleaned).toString(CryptoJS.enc.Hex).substring(0, 32);
+  }
+
+  /**
+   * Generate random keypair for testing
+   */
+  static randomKeypair(): Keypair {
+    return Keypair.random();
+  }
+}
diff --git a/apps/web/stellar-social-sdk/test-quick.js b/apps/web/stellar-social-sdk/test-quick.js
new file mode 100644
index 00000000..42db7757
--- /dev/null
+++ b/apps/web/stellar-social-sdk/test-quick.js
@@ -0,0 +1,44 @@
+import { StellarSocialSDK } from './dist/index.esm.js';
+
+async function testSDK() {
+  console.log('🚀 Testing Stellar Social SDK...');
+  
+  const sdk = new StellarSocialSDK({
+    contractId: 'CALZGCSB3P3WEBLW3QTF5Y4WEALEVTYUYBC7KBGQ266GDINT7U4E74KW',
+    network: 'testnet'
+  });
+
+  await sdk.initialize();
+
+  try {
+    console.log('\n📧 Testing Google authentication...');
+    const googleResult = await sdk.authenticateWithGoogle();
+    
+    if (googleResult.success && googleResult.account) {
+      console.log('✅ Google auth successful!');
+      console.log('Address:', googleResult.account.publicKey);
+      
+      // Test balance
+      const balances = await googleResult.account.getBalance();
+      console.log('💰 Balances:', balances);
+      
+      console.log('\n📱 Testing add auth method...');
+      await googleResult.account.addAuthMethod({
+        type: 'phone',
+        identifier: '+1234567890',
+        metadata: { verified: true }
+      });
+      
+      console.log('Auth methods:', googleResult.account.authMethods.length);
+    }
+
+    console.log('\n🔵 Testing Facebook authentication...');
+    const fbResult = await sdk.authenticateWithFacebook();
+    console.log('Facebook result:', fbResult.success ? 'SUCCESS' : 'FAILED');
+
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+  }
+}
+
+testSDK().catch(console.error);
diff --git a/apps/web/stellar-social-sdk/tsconfig.json b/apps/web/stellar-social-sdk/tsconfig.json
new file mode 100644
index 00000000..692fb1df
--- /dev/null
+++ b/apps/web/stellar-social-sdk/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext", 
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
\ No newline at end of file
diff --git a/apps/web/tsconfig.json b/apps/web/tsconfig.json
index 07b8f614..5f10df00 100644
--- a/apps/web/tsconfig.json
+++ b/apps/web/tsconfig.json
@@ -24,7 +24,8 @@
     "baseUrl": ".",
     "paths": {
       "~/*": ["./src/*"],
-      "@/*": ["./src/*"]
+      "@/*": ["./src/*"],
+      "stellar-social-sdk": ["./stellar-social-sdk/dist/index.esm.js"]
     },
     "incremental": true,
     "esModuleInterop": true,
diff --git a/biome.json b/biome.json
index 20675ce2..154d80c1 100644
--- a/biome.json
+++ b/biome.json
@@ -16,7 +16,9 @@
       "**/*.snap",
       "**/__snapshots__/**",
       "**/*.lock",
-      "apps/backend/src/config/supabase.ts"
+      "apps/backend/src/config/supabase.ts",
+      "apps/backend/tests/**/*.ts",
+      "apps/web/stellar-social-sdk"
     ]
   },
   "formatter": {
diff --git a/bun.lock b/bun.lock
index fe31f4c8..ca452974 100644
--- a/bun.lock
+++ b/bun.lock
@@ -102,6 +102,7 @@
         "sodium-universal": "^5.0.1",
         "sonner": "^2.0.6",
         "stellar-sdk": "^13.3.0",
+        "stellar-social-sdk": "file:./stellar-social-sdk",
         "tailwind-merge": "^3.2.0",
         "tailwindcss-animate": "^1.0.7",
         "zod": "^3.24.3",
@@ -523,6 +524,64 @@
 
     "@redis/time-series": ["@redis/time-series@1.1.0", "", { "peerDependencies": { "@redis/client": "^1.0.0" } }, "sha512-c1Q99M5ljsIuc4YdaCwfUEXsofakb9c8+Zse2qxTadu8TalLXuAESzLvFAvNVbkmSlvlzIQOLpBCmWI9wTOt+g=="],
 
+    "@rollup/plugin-commonjs": ["@rollup/plugin-commonjs@25.0.8", "", { "dependencies": { "@rollup/pluginutils": "^5.0.1", "commondir": "^1.0.1", "estree-walker": "^2.0.2", "glob": "^8.0.3", "is-reference": "1.2.1", "magic-string": "^0.30.3" }, "peerDependencies": { "rollup": "^2.68.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-ZEZWTK5n6Qde0to4vS9Mr5x/0UZoqCxPVR9KRUjU4kA2sO7GEUn1fop0DAwpO6z0Nw/kJON9bDmSxdWxO/TT1A=="],
+
+    "@rollup/plugin-node-resolve": ["@rollup/plugin-node-resolve@15.3.1", "", { "dependencies": { "@rollup/pluginutils": "^5.0.1", "@types/resolve": "1.20.2", "deepmerge": "^4.2.2", "is-module": "^1.0.0", "resolve": "^1.22.1" }, "peerDependencies": { "rollup": "^2.78.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-tgg6b91pAybXHJQMAAwW9VuWBO6Thi+q7BCNARLwSqlmsHz0XYURtGvh/AuwSADXSI4h/2uHbs7s4FzlZDGSGA=="],
+
+    "@rollup/plugin-typescript": ["@rollup/plugin-typescript@11.1.6", "", { "dependencies": { "@rollup/pluginutils": "^5.1.0", "resolve": "^1.22.1" }, "peerDependencies": { "rollup": "^2.14.0||^3.0.0||^4.0.0", "tslib": "*", "typescript": ">=3.7.0" }, "optionalPeers": ["rollup", "tslib"] }, "sha512-R92yOmIACgYdJ7dJ97p4K69I8gg6IEHt8M7dUBxN3W6nrO8uUxX5ixl0yU/N3aZTi8WhPuICvOHXQvF6FaykAA=="],
+
+    "@rollup/pluginutils": ["@rollup/pluginutils@5.3.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.56.0", "", { "os": "android", "cpu": "arm" }, "sha512-LNKIPA5k8PF1+jAFomGe3qN3bbIgJe/IlpDBwuVjrDKrJhVWywgnJvflMt/zkbVNLFtF1+94SljYQS6e99klnw=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.56.0", "", { "os": "android", "cpu": "arm64" }, "sha512-lfbVUbelYqXlYiU/HApNMJzT1E87UPGvzveGg2h0ktUNlOCxKlWuJ9jtfvs1sKHdwU4fzY7Pl8sAl49/XaEk6Q=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.56.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-EgxD1ocWfhoD6xSOeEEwyE7tDvwTgZc8Bss7wCWe+uc7wO8G34HHCUH+Q6cHqJubxIAnQzAsyUsClt0yFLu06w=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.56.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-1vXe1vcMOssb/hOF8iv52A7feWW2xnu+c8BV4t1F//m9QVLTfNVpEdja5ia762j/UEJe2Z1jAmEqZAK42tVW3g=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.56.0", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-bof7fbIlvqsyv/DtaXSck4VYQ9lPtoWNFCB/JY4snlFuJREXfZnm+Ej6yaCHfQvofJDXLDMTVxWscVSuQvVWUQ=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.56.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-KNa6lYHloW+7lTEkYGa37fpvPq+NKG/EHKM8+G/g9WDU7ls4sMqbVRV78J6LdNuVaeeK5WB9/9VAFbKxcbXKYg=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.56.0", "", { "os": "linux", "cpu": "arm" }, "sha512-E8jKK87uOvLrrLN28jnAAAChNq5LeCd2mGgZF+fGF5D507WlG/Noct3lP/QzQ6MrqJ5BCKNwI9ipADB6jyiq2A=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.56.0", "", { "os": "linux", "cpu": "arm" }, "sha512-jQosa5FMYF5Z6prEpTCCmzCXz6eKr/tCBssSmQGEeozA9tkRUty/5Vx06ibaOP9RCrW1Pvb8yp3gvZhHwTDsJw=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.56.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-uQVoKkrC1KGEV6udrdVahASIsaF8h7iLG0U0W+Xn14ucFwi6uS539PsAr24IEF9/FoDtzMeeJXJIBo5RkbNWvQ=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.56.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-vLZ1yJKLxhQLFKTs42RwTwa6zkGln+bnXc8ueFGMYmBTLfNu58sl5/eXyxRa2RarTkJbXl8TKPgfS6V5ijNqEA=="],
+
+    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.56.0", "", { "os": "linux", "cpu": "none" }, "sha512-FWfHOCub564kSE3xJQLLIC/hbKqHSVxy8vY75/YHHzWvbJL7aYJkdgwD/xGfUlL5UV2SB7otapLrcCj2xnF1dg=="],
+
+    "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.56.0", "", { "os": "linux", "cpu": "none" }, "sha512-z1EkujxIh7nbrKL1lmIpqFTc/sr0u8Uk0zK/qIEFldbt6EDKWFk/pxFq3gYj4Bjn3aa9eEhYRlL3H8ZbPT1xvA=="],
+
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.56.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-iNFTluqgdoQC7AIE8Q34R3AuPrJGJirj5wMUErxj22deOcY7XwZRaqYmB6ZKFHoVGqRcRd0mqO+845jAibKCkw=="],
+
+    "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.56.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-MtMeFVlD2LIKjp2sE2xM2slq3Zxf9zwVuw0jemsxvh1QOpHSsSzfNOTH9uYW9i1MXFxUSMmLpeVeUzoNOKBaWg=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.56.0", "", { "os": "linux", "cpu": "none" }, "sha512-in+v6wiHdzzVhYKXIk5U74dEZHdKN9KH0Q4ANHOTvyXPG41bajYRsy7a8TPKbYPl34hU7PP7hMVHRvv/5aCSew=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.56.0", "", { "os": "linux", "cpu": "none" }, "sha512-yni2raKHB8m9NQpI9fPVwN754mn6dHQSbDTwxdr9SE0ks38DTjLMMBjrwvB5+mXrX+C0npX0CVeCUcvvvD8CNQ=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.56.0", "", { "os": "linux", "cpu": "s390x" }, "sha512-zhLLJx9nQPu7wezbxt2ut+CI4YlXi68ndEve16tPc/iwoylWS9B3FxpLS2PkmfYgDQtosah07Mj9E0khc3Y+vQ=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.56.0", "", { "os": "linux", "cpu": "x64" }, "sha512-MVC6UDp16ZSH7x4rtuJPAEoE1RwS8N4oK9DLHy3FTEdFoUTCFVzMfJl/BVJ330C+hx8FfprA5Wqx4FhZXkj2Kw=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.56.0", "", { "os": "linux", "cpu": "x64" }, "sha512-ZhGH1eA4Qv0lxaV00azCIS1ChedK0V32952Md3FtnxSqZTBTd6tgil4nZT5cU8B+SIw3PFYkvyR4FKo2oyZIHA=="],
+
+    "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.56.0", "", { "os": "openbsd", "cpu": "x64" }, "sha512-O16XcmyDeFI9879pEcmtWvD/2nyxR9mF7Gs44lf1vGGx8Vg2DRNx11aVXBEqOQhWb92WN4z7fW/q4+2NYzCbBA=="],
+
+    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.56.0", "", { "os": "none", "cpu": "arm64" }, "sha512-LhN/Reh+7F3RCgQIRbgw8ZMwUwyqJM+8pXNT6IIJAqm2IdKkzpCh/V9EdgOMBKuebIrzswqy4ATlrDgiOwbRcQ=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.56.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-kbFsOObXp3LBULg1d3JIUQMa9Kv4UitDmpS+k0tinPBz3watcUiV2/LUDMMucA6pZO3WGE27P7DsfaN54l9ing=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.56.0", "", { "os": "win32", "cpu": "ia32" }, "sha512-vSSgny54D6P4vf2izbtFm/TcWYedw7f8eBrOiGGecyHyQB9q4Kqentjaj8hToe+995nob/Wv48pDqL5a62EWtg=="],
+
+    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.56.0", "", { "os": "win32", "cpu": "x64" }, "sha512-FeCnkPCTHQJFbiGG49KjV5YGW/8b9rrXAM2Mz2kiIoktq2qsJxRD5giEMEOD2lPdgs72upzefaUvS+nc8E3UzQ=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.56.0", "", { "os": "win32", "cpu": "x64" }, "sha512-H8AE9Ur/t0+1VXujj90w0HrSOuv0Nq9r1vSZF2t5km20NTfosQsGGUXDaKdQZzwuLts7IyL1fYT4hM95TI9c4g=="],
+
     "@rtsao/scc": ["@rtsao/scc@1.1.0", "", {}, "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g=="],
 
     "@rushstack/eslint-patch": ["@rushstack/eslint-patch@1.12.0", "", {}, "sha512-5EwMtOqvJMMa3HbmxLlF74e+3/HhwBTMcvt3nqVJgGCozO6hzIPOBlwm8mGVNR9SN2IJpxSnlxczyDjcn7qIyw=="],
@@ -611,6 +670,8 @@
 
     "@types/cors": ["@types/cors@2.8.19", "", { "dependencies": { "@types/node": "*" } }, "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg=="],
 
+    "@types/crypto-js": ["@types/crypto-js@4.2.2", "", {}, "sha512-sDOLlVbHhXpAUAL0YHDUUwDZf3iN4Bwi4W6a0W0b+QcAezUbRtH4FVb+9J4h+XFPW7l/gQ9F8qC7P+Ec4k8QVQ=="],
+
     "@types/eslint": ["@types/eslint@9.6.1", "", { "dependencies": { "@types/estree": "*", "@types/json-schema": "*" } }, "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag=="],
 
     "@types/eslint-scope": ["@types/eslint-scope@3.7.7", "", { "dependencies": { "@types/eslint": "*", "@types/estree": "*" } }, "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg=="],
@@ -671,6 +732,8 @@
 
     "@types/react-dom": ["@types/react-dom@18.3.7", "", { "peerDependencies": { "@types/react": "^18.0.0" } }, "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ=="],
 
+    "@types/resolve": ["@types/resolve@1.20.2", "", {}, "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q=="],
+
     "@types/send": ["@types/send@0.17.5", "", { "dependencies": { "@types/mime": "^1", "@types/node": "*" } }, "sha512-z6F2D3cOStZvuk2SaP6YrwkNO65iTZcwA2ZkSABegdkAh/lf+Aa/YQndZVfmEXT5vgAp6zv06VQ3ejSVjAny4w=="],
 
     "@types/serve-static": ["@types/serve-static@1.15.8", "", { "dependencies": { "@types/http-errors": "*", "@types/node": "*", "@types/send": "*" } }, "sha512-roei0UY3LhpOJvjbIP6ZZFngyLKl5dskOtDhxY5THRSpO+ZI+nzJ+m5yUMzGrp89YRa7lvknKkMYjqQFGwA7Sg=="],
@@ -1039,6 +1102,8 @@
 
     "commander": ["commander@2.20.3", "", {}, "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="],
 
+    "commondir": ["commondir@1.0.1", "", {}, "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg=="],
+
     "compare-func": ["compare-func@2.0.0", "", { "dependencies": { "array-ify": "^1.0.0", "dot-prop": "^5.1.0" } }, "sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA=="],
 
     "component-emitter": ["component-emitter@1.3.1", "", {}, "sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ=="],
@@ -1115,6 +1180,8 @@
 
     "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
 
+    "crypto-js": ["crypto-js@4.2.0", "", {}, "sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q=="],
+
     "cssesc": ["cssesc@3.0.0", "", { "bin": "bin/cssesc" }, "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg=="],
 
     "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
@@ -1289,6 +1356,8 @@
 
     "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
 
+    "estree-walker": ["estree-walker@2.0.2", "", {}, "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="],
+
     "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="],
 
     "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],
@@ -1569,6 +1638,8 @@
 
     "is-map": ["is-map@2.0.3", "", {}, "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw=="],
 
+    "is-module": ["is-module@1.0.0", "", {}, "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g=="],
+
     "is-negative-zero": ["is-negative-zero@2.0.3", "", {}, "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw=="],
 
     "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
@@ -1581,6 +1652,8 @@
 
     "is-plain-obj": ["is-plain-obj@1.1.0", "", {}, "sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg=="],
 
+    "is-reference": ["is-reference@1.2.1", "", { "dependencies": { "@types/estree": "*" } }, "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ=="],
+
     "is-regex": ["is-regex@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g=="],
 
     "is-retry-allowed": ["is-retry-allowed@3.0.0", "", {}, "sha512-9xH0xvoggby+u0uGF7cZXdrutWiBiaFG8ZT4YFPXL8NzkyAwX3AKGLeFQLvzDpM430+nDFBZ1LHkie/8ocL06A=="],
@@ -1689,6 +1762,8 @@
 
     "joi": ["joi@17.13.3", "", { "dependencies": { "@hapi/hoek": "^9.3.0", "@hapi/topo": "^5.1.0", "@sideway/address": "^4.1.5", "@sideway/formula": "^3.0.1", "@sideway/pinpoint": "^2.0.0" } }, "sha512-otDA4ldcIx+ZXsKHWmp0YizCweVRZG96J10b0FevjfuncLO1oX59THoAmHkNubYJ+9gWsYsp5k8v4ib6oDv1fA=="],
 
+    "jose": ["jose@5.10.0", "", {}, "sha512-s+3Al/p9g32Iq+oqXxkW//7jk2Vig6FF1CFqzVXoTUXt2qz89YWbL+OwS17NFYEvxC35n0FKeGO2LGYSxeM2Gg=="],
+
     "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
 
     "js-xdr": ["js-xdr@1.3.0", "", { "dependencies": { "lodash": "^4.17.5", "long": "^2.2.3" } }, "sha512-fjLTm2uBtFvWsE3l2J14VjTuuB8vJfeTtYuNS7LiLHDWIX2kt0l1pqq9334F8kODUkKPMuULjEcbGbkFFwhx5g=="],
@@ -1819,6 +1894,8 @@
 
     "lucide-react": ["lucide-react@0.488.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-ronlL0MyKut4CEzBY/ai2ZpKPxyWO4jUqdAkm2GNK5Zn3Rj+swDz+3lvyAUXN0PNqPKIX6XM9Xadwz/skLs/pQ=="],
 
+    "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
+
     "make-dir": ["make-dir@3.1.0", "", { "dependencies": { "semver": "^6.0.0" } }, "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw=="],
 
     "make-error": ["make-error@1.3.6", "", {}, "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw=="],
@@ -2131,6 +2208,10 @@
 
     "roarr": ["roarr@2.15.4", "", { "dependencies": { "boolean": "^3.0.1", "detect-node": "^2.0.4", "globalthis": "^1.0.1", "json-stringify-safe": "^5.0.1", "semver-compare": "^1.0.0", "sprintf-js": "^1.1.2" } }, "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A=="],
 
+    "rollup": ["rollup@4.56.0", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.56.0", "@rollup/rollup-android-arm64": "4.56.0", "@rollup/rollup-darwin-arm64": "4.56.0", "@rollup/rollup-darwin-x64": "4.56.0", "@rollup/rollup-freebsd-arm64": "4.56.0", "@rollup/rollup-freebsd-x64": "4.56.0", "@rollup/rollup-linux-arm-gnueabihf": "4.56.0", "@rollup/rollup-linux-arm-musleabihf": "4.56.0", "@rollup/rollup-linux-arm64-gnu": "4.56.0", "@rollup/rollup-linux-arm64-musl": "4.56.0", "@rollup/rollup-linux-loong64-gnu": "4.56.0", "@rollup/rollup-linux-loong64-musl": "4.56.0", "@rollup/rollup-linux-ppc64-gnu": "4.56.0", "@rollup/rollup-linux-ppc64-musl": "4.56.0", "@rollup/rollup-linux-riscv64-gnu": "4.56.0", "@rollup/rollup-linux-riscv64-musl": "4.56.0", "@rollup/rollup-linux-s390x-gnu": "4.56.0", "@rollup/rollup-linux-x64-gnu": "4.56.0", "@rollup/rollup-linux-x64-musl": "4.56.0", "@rollup/rollup-openbsd-x64": "4.56.0", "@rollup/rollup-openharmony-arm64": "4.56.0", "@rollup/rollup-win32-arm64-msvc": "4.56.0", "@rollup/rollup-win32-ia32-msvc": "4.56.0", "@rollup/rollup-win32-x64-gnu": "4.56.0", "@rollup/rollup-win32-x64-msvc": "4.56.0", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-9FwVqlgUHzbXtDg9RCMgodF3Ua4Na6Gau+Sdt9vyCN4RhHfVKX2DCHy3BjMLTDd47ITDhYAnTwGulWTblJSDLg=="],
+
+    "rollup-plugin-dts": ["rollup-plugin-dts@6.3.0", "", { "dependencies": { "magic-string": "^0.30.21" }, "optionalDependencies": { "@babel/code-frame": "^7.27.1" }, "peerDependencies": { "rollup": "^3.29.4 || ^4", "typescript": "^4.5 || ^5.0" } }, "sha512-d0UrqxYd8KyZ6i3M2Nx7WOMy708qsV/7fTHMHxCMCBOAe3V/U7OMPu5GkX8hC+cmkHhzGnfeYongl1IgiooddA=="],
+
     "run-async": ["run-async@0.1.0", "", { "dependencies": { "once": "^1.3.0" } }, "sha512-qOX+w+IxFgpUpJfkv2oGN0+ExPs68F4sZHfaRRx4dDexAQkG83atugKVEylyT5ARees3HBbfmuvnjbrd8j9Wjw=="],
 
     "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
@@ -2599,6 +2680,10 @@
 
     "@react-leaflet/core/react-dom": ["react-dom@19.2.0", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.0" } }, "sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ=="],
 
+    "@rollup/plugin-commonjs/glob": ["glob@8.1.0", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^5.0.1", "once": "^1.3.0" } }, "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ=="],
+
+    "@rollup/pluginutils/picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
+
     "@stellar/stellar-base/sodium-native": ["sodium-native@4.3.3", "", { "dependencies": { "require-addon": "^1.1.0" } }, "sha512-OnxSlN3uyY8D0EsLHpmm2HOFmKddQVvEMmsakCrXUzSd8kjjbzL413t4ZNF3n0UxSwNgwTyUvkmZHTfuCeiYSw=="],
 
     "@stellar/stellar-sdk/axios": ["axios@1.11.0", "", { "dependencies": { "follow-redirects": "^1.15.6", "form-data": "^4.0.4", "proxy-from-env": "^1.1.0" } }, "sha512-1Lx3WLFQWm3ooKDYZD1eXmoGO9fxYQjrycfHFC8P0sCfQVXyROp0p9PFWBehewBOdCwHc+f/b8I0fMto5eSfwA=="],
@@ -2951,6 +3036,8 @@
 
     "lru-cache/yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
 
+    "magic-string/@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
     "make-dir/semver": ["semver@6.3.1", "", { "bin": "bin/semver.js" }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
 
     "meow/read-pkg-up": ["read-pkg-up@7.0.1", "", { "dependencies": { "find-up": "^4.1.0", "read-pkg": "^5.2.0", "type-fest": "^0.8.1" } }, "sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg=="],
@@ -2999,6 +3086,8 @@
 
     "roarr/sprintf-js": ["sprintf-js@1.1.3", "", {}, "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA=="],
 
+    "rollup/fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
     "schema-utils/ajv": ["ajv@8.17.1", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g=="],
 
     "send/debug": ["debug@2.6.9", "", { "dependencies": { "ms": "2.0.0" } }, "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA=="],
@@ -3059,6 +3148,8 @@
 
     "tsconfig-paths/strip-bom": ["strip-bom@3.0.0", "", {}, "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA=="],
 
+    "web/stellar-social-sdk": ["stellar-social-sdk@file:apps/web/stellar-social-sdk", { "dependencies": { "@stellar/stellar-sdk": "^12.3.0", "axios": "^1.6.0", "crypto-js": "^4.2.0", "jose": "^5.2.0" }, "devDependencies": { "@rollup/plugin-commonjs": "^25.0.0", "@rollup/plugin-node-resolve": "^15.2.0", "@rollup/plugin-typescript": "^11.1.0", "@types/crypto-js": "^4.2.0", "@types/node": "^20.10.0", "rollup": "^4.0.0", "rollup-plugin-dts": "^6.1.0", "typescript": "^5.3.0" } }],
+
     "webpack/eslint-scope": ["eslint-scope@5.1.1", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^4.1.1" } }, "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw=="],
 
     "wide-align/string-width": ["string-width@1.0.2", "", { "dependencies": { "code-point-at": "^1.0.0", "is-fullwidth-code-point": "^1.0.0", "strip-ansi": "^3.0.0" } }, "sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw=="],
@@ -3165,6 +3256,8 @@
 
     "@react-leaflet/core/react-dom/scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
 
+    "@rollup/plugin-commonjs/glob/minimatch": ["minimatch@5.1.6", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g=="],
+
     "@types/bcrypt/@types/node/undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
 
     "@types/body-parser/@types/node/undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
@@ -3473,6 +3566,8 @@
 
     "terser/source-map-support/source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
 
+    "web/stellar-social-sdk/@stellar/stellar-sdk": ["@stellar/stellar-sdk@12.3.0", "", { "dependencies": { "@stellar/stellar-base": "^12.1.1", "axios": "^1.7.7", "bignumber.js": "^9.1.2", "eventsource": "^2.0.2", "randombytes": "^2.1.0", "toml": "^3.0.0", "urijs": "^1.19.1" } }, "sha512-F2DYFop/M5ffXF0lvV5Ezjk+VWNKg0QDX8gNhwehVU3y5LYA3WAY6VcCarMGPaG9Wdgoeh1IXXzOautpqpsltw=="],
+
     "webpack/eslint-scope/estraverse": ["estraverse@4.3.0", "", {}, "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw=="],
 
     "wide-align/string-width/is-fullwidth-code-point": ["is-fullwidth-code-point@1.0.0", "", { "dependencies": { "number-is-nan": "^1.0.0" } }, "sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw=="],
@@ -3565,6 +3660,8 @@
 
     "@jest/types/chalk/supports-color/has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
 
+    "@rollup/plugin-commonjs/glob/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="],
+
     "babel-jest/chalk/ansi-styles/color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
 
     "babel-jest/chalk/supports-color/has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
@@ -3739,6 +3836,8 @@
 
     "terser-webpack-plugin/jest-worker/supports-color/has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
 
+    "web/stellar-social-sdk/@stellar/stellar-sdk/@stellar/stellar-base": ["@stellar/stellar-base@12.1.1", "", { "dependencies": { "@stellar/js-xdr": "^3.1.2", "base32.js": "^0.1.0", "bignumber.js": "^9.1.2", "buffer": "^6.0.3", "sha.js": "^2.3.6", "tweetnacl": "^1.0.3" }, "optionalDependencies": { "sodium-native": "^4.1.1" } }, "sha512-gOBSOFDepihslcInlqnxKZdIW9dMUO1tpOm3AtJR33K2OvpXG6SaVHCzAmCFArcCqI9zXTEiSoh70T48TmiHJA=="],
+
     "wide-align/string-width/strip-ansi/ansi-regex": ["ansi-regex@2.1.1", "", {}, "sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA=="],
 
     "wrap-ansi-cjs/ansi-styles/color-convert/color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
@@ -3877,6 +3976,8 @@
 
     "stellar-cli/stellar-sdk/axios/follow-redirects/debug": ["debug@3.1.0", "", { "dependencies": { "ms": "2.0.0" } }, "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g=="],
 
+    "web/stellar-social-sdk/@stellar/stellar-sdk/@stellar/stellar-base/sodium-native": ["sodium-native@4.3.3", "", { "dependencies": { "require-addon": "^1.1.0" } }, "sha512-OnxSlN3uyY8D0EsLHpmm2HOFmKddQVvEMmsakCrXUzSd8kjjbzL413t4ZNF3n0UxSwNgwTyUvkmZHTfuCeiYSw=="],
+
     "@commitlint/top-level/find-up/locate-path/p-locate/p-limit/yocto-queue": ["yocto-queue@1.2.1", "", {}, "sha512-AyeEbWOu/TAXdxlV9wmGcR0+yh2j3vYPGOECcIj2S7MkrLyC7ne+oye2BKTItt0ii2PHk4cDy+95+LshzbXnGg=="],
 
     "@jest/environment/@jest/types/chalk/ansi-styles/color-convert/color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],