@hsuite/native-connect-angular 1.0.0

package/src/lib/services/unified-wallet.service.spec.ts

@@ -0,0 +1,1382 @@
+/**
+ * @fileoverview Unit tests for UnifiedWalletService
+ *
+ * Tests cover:
+ * - Provider registration/unregistration
+ * - Connection management (connect, disconnect, disconnectAll)
+ * - Account management (active account, switching, filtering)
+ * - Transaction operations (sign, submit, signAndExecute, signMessage)
+ * - Session management (active sessions, session disconnect)
+ * - Provider queries (by ID, by type, summaries)
+ * - Event bus integration
+ * - Reconnection handling
+ * - Transport state tracking
+ * - Error handling
+ *
+ * @module services/unified-wallet
+ * @since 2.0.0
+ */
+
+import { describe, it, expect, beforeEach, vi, type MockedFunction } from 'vitest';
+import { signal, WritableSignal } from '@angular/core';
+import type { UnifiedAccount } from '../models/unified-account.model';
+import type { ConnectionStatus, ProviderMetadata, ProviderType } from '../models/provider-types';
+import type { ConnectionConfig } from '../models/connection-config.model';
+import type {
+  SignTransactionOptions,
+  SubmitTransactionOptions,
+  SignMessageOptions,
+  SignResult,
+  SubmitResult,
+  SignMessageResult,
+} from '../providers/base-wallet-provider';
+
+// Mock the logger
+vi.mock('@hsuite/native-connect-sdk', () => ({
+  getLogger: vi.fn(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    scoped: vi.fn(() => ({
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    })),
+  })),
+}));
+
+/**
+ * Mock implementation of BaseWalletProvider for testing
+ */
+class MockWalletProvider {
+  readonly id: string;
+  readonly metadata: ProviderMetadata;
+  private _status: WritableSignal<ConnectionStatus>;
+  private _accounts: WritableSignal<UnifiedAccount[]>;
+  private _error: WritableSignal<string | null>;
+
+  // Mock functions
+  connect = vi.fn<[ConnectionConfig], Promise<void>>();
+  disconnect = vi.fn<[], Promise<void>>();
+  signTransaction = vi.fn<[SignTransactionOptions], Promise<SignResult>>();
+  submitTransaction = vi.fn<[SubmitTransactionOptions], Promise<SubmitResult>>();
+  signMessage = vi.fn<[SignMessageOptions], Promise<SignMessageResult>>();
+  isAvailable = vi.fn<[], Promise<boolean>>();
+
+  // Optional methods that some providers have
+  attemptReconnect?: MockedFunction<() => Promise<boolean>>;
+  getActiveSessions?: MockedFunction<() => unknown[]>;
+  disconnectSession?: MockedFunction<(sessionKey: string) => Promise<void>>;
+  signAndExecuteTransaction?: MockedFunction<(options: unknown) => Promise<unknown>>;
+  transportState?: () => string;
+
+  constructor(
+    id: string,
+    type: ProviderType,
+    name: string,
+    options?: {
+      supportsReconnect?: boolean;
+      supportsSessions?: boolean;
+      supportsSignAndExecute?: boolean;
+      transportState?: () => string;
+    },
+  ) {
+    this.id = id;
+    this.metadata = {
+      name,
+      type,
+      description: `Mock ${name} provider`,
+    };
+    this._status = signal<ConnectionStatus>('disconnected');
+    this._accounts = signal<UnifiedAccount[]>([]);
+    this._error = signal<string | null>(null);
+
+    if (options?.supportsReconnect) {
+      this.attemptReconnect = vi.fn<[], Promise<boolean>>().mockResolvedValue(true);
+    }
+    if (options?.supportsSessions) {
+      this.getActiveSessions = vi.fn<[], unknown[]>().mockReturnValue([]);
+      this.disconnectSession = vi.fn<[string], Promise<void>>().mockResolvedValue(undefined);
+    }
+    if (options?.supportsSignAndExecute) {
+      this.signAndExecuteTransaction = vi.fn<[unknown], Promise<unknown>>().mockResolvedValue({
+        transactionId: 'tx-123',
+      });
+    }
+    if (options?.transportState) {
+      this.transportState = options.transportState;
+    }
+
+    // Default implementations
+    this.connect.mockResolvedValue(undefined);
+    this.disconnect.mockImplementation(async () => {
+      this._status.set('disconnected');
+      this._accounts.set([]);
+    });
+    this.signTransaction.mockResolvedValue({ signedPayload: 'signed-payload' });
+    this.submitTransaction.mockResolvedValue({ transactionId: 'tx-123' });
+    this.signMessage.mockResolvedValue({ signature: 'sig-123' });
+    this.isAvailable.mockResolvedValue(true);
+  }
+
+  get status() {
+    return this._status.asReadonly();
+  }
+
+  get accounts() {
+    return this._accounts.asReadonly();
+  }
+
+  get error() {
+    return this._error.asReadonly();
+  }
+
+  // Helper methods for tests
+  setStatus(status: ConnectionStatus): void {
+    this._status.set(status);
+  }
+
+  setAccounts(accounts: UnifiedAccount[]): void {
+    this._accounts.set(accounts);
+  }
+
+  setError(error: string | null): void {
+    this._error.set(error);
+  }
+
+  isConnected(): boolean {
+    return this._status() === 'connected';
+  }
+
+  getPrimaryAccount(): UnifiedAccount | null {
+    const accts = this._accounts();
+    return accts.length > 0 ? accts[0] : null;
+  }
+}
+
+/**
+ * Mock WalletEventBus
+ */
+class MockWalletEventBus {
+  connected = { emit: vi.fn() };
+  disconnected = { emit: vi.fn() };
+  accountChanged = { emit: vi.fn() };
+  accountsUpdated = { emit: vi.fn() };
+  sessionCreated = { emit: vi.fn() };
+  sessionDeleted = { emit: vi.fn() };
+  sessionRestored = { emit: vi.fn() };
+  providerStatusChanged = { emit: vi.fn() };
+  providerError = { emit: vi.fn() };
+}
+
+/**
+ * Create test accounts
+ */
+function createMockAccount(overrides: Partial<UnifiedAccount> = {}): UnifiedAccount {
+  return {
+    id: 'account-1',
+    address: '0.0.12345',
+    ledgerId: 'hedera',
+    networkId: 'hedera:testnet',
+    providerId: 'hsuite-native',
+    providerType: 'hsuite-native',
+    ...overrides,
+  };
+}
+
+/**
+ * UnifiedWalletService test harness
+ *
+ * Since the actual service uses Angular DI, we create a simplified test version
+ * that mirrors the core functionality for unit testing.
+ */
+class TestableUnifiedWalletService {
+  private readonly providers = new Map<string, MockWalletProvider>();
+  private readonly _providerIds = signal<string[]>([]);
+  private readonly _activeAccount = signal<UnifiedAccount | null>(null);
+  private readonly eventBus: MockWalletEventBus;
+
+  constructor(
+    hsuiteProvider: MockWalletProvider,
+    walletConnectProvider: MockWalletProvider,
+    p2pNativeProvider: MockWalletProvider,
+    eventBus: MockWalletEventBus,
+  ) {
+    this.eventBus = eventBus;
+
+    // Auto-register built-in providers
+    this.registerProvider(hsuiteProvider);
+    this.registerProvider(walletConnectProvider);
+    this.registerProvider(p2pNativeProvider);
+  }
+
+  get allAccounts(): UnifiedAccount[] {
+    const providers = Array.from(this.providers.values());
+    return providers.flatMap((p) => p.accounts());
+  }
+
+  get activeAccount(): UnifiedAccount | null {
+    return this._activeAccount();
+  }
+
+  get connectedProviders(): MockWalletProvider[] {
+    return Array.from(this.providers.values()).filter((p) => p.isConnected());
+  }
+
+  get transportState(): string {
+    // Check HSuite Native provider first
+    const hsuiteProvider = this.providers.get('hsuite-native');
+    if (hsuiteProvider) {
+      const status = hsuiteProvider.status();
+      if ((status === 'connecting' || status === 'connected') && hsuiteProvider.transportState) {
+        return hsuiteProvider.transportState();
+      }
+    }
+
+    // Check P2P Native provider
+    const p2pProvider = this.providers.get('mobile-native');
+    if (p2pProvider) {
+      const status = p2pProvider.status();
+      if ((status === 'connecting' || status === 'connected') && p2pProvider.transportState) {
+        return p2pProvider.transportState();
+      }
+    }
+
+    return 'idle';
+  }
+
+  getProviderSummaries() {
+    return Array.from(this.providers.values()).map((provider) => ({
+      id: provider.id,
+      name: provider.metadata.name,
+      providerType: provider.metadata.type,
+      status: provider.status(),
+      accounts: provider.accounts(),
+      supportsReconnect: typeof provider.attemptReconnect === 'function',
+    }));
+  }
+
+  async reconnectProvider(providerId: string): Promise<boolean> {
+    const provider = this.providers.get(providerId);
+    if (!provider) {
+      return false;
+    }
+    if (typeof provider.attemptReconnect === 'function') {
+      try {
+        return await provider.attemptReconnect();
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  registerProvider(provider: MockWalletProvider): void {
+    if (this.providers.has(provider.id)) {
+      return;
+    }
+    this.providers.set(provider.id, provider);
+    this._providerIds.set(Array.from(this.providers.keys()));
+  }
+
+  unregisterProvider(providerId: string): void {
+    this.providers.delete(providerId);
+    this._providerIds.set(Array.from(this.providers.keys()));
+  }
+
+  getProvider(providerId: string): MockWalletProvider | undefined {
+    return this.providers.get(providerId);
+  }
+
+  getProvidersByType(type: ProviderType): MockWalletProvider[] {
+    return Array.from(this.providers.values()).filter((p) => p.metadata.type === type);
+  }
+
+  async connect(providerId: string, config: ConnectionConfig): Promise<void> {
+    const provider = this.providers.get(providerId);
+    if (!provider) {
+      throw new Error(`Provider ${providerId} not found`);
+    }
+
+    await provider.connect(config);
+
+    const accounts = provider.accounts();
+
+    // Emit connection event
+    this.eventBus.connected.emit({
+      providerId,
+      providerType: provider.metadata.type,
+      accounts,
+      timestamp: Date.now(),
+    });
+
+    // Emit accounts updated
+    this.eventBus.accountsUpdated.emit({
+      providerId,
+      accounts,
+      totalAccounts: this.allAccounts.length,
+      timestamp: Date.now(),
+    });
+
+    // Auto-select first account if none is active
+    if (!this._activeAccount() && provider.accounts().length > 0) {
+      this.setActiveAccount(provider.accounts()[0]);
+    }
+  }
+
+  async disconnect(providerId: string): Promise<void> {
+    const provider = this.providers.get(providerId);
+    if (!provider) {
+      throw new Error(`Provider ${providerId} not found`);
+    }
+
+    await provider.disconnect();
+
+    // If the active account belonged to this provider, clear it
+    const active = this._activeAccount();
+    if (active && active.providerId === providerId) {
+      const accounts = this.allAccounts;
+      const nextAccount = accounts.find((a) => a.providerId !== providerId);
+      this.setActiveAccount(nextAccount || null);
+    }
+  }
+
+  async disconnectAll(): Promise<void> {
+    const disconnectPromises = Array.from(this.providers.values())
+      .filter((p) => p.isConnected())
+      .map((p) => p.disconnect());
+
+    await Promise.all(disconnectPromises);
+    this.setActiveAccount(null);
+  }
+
+  setActiveAccount(account: UnifiedAccount | null): void {
+    const previous = this._activeAccount();
+    this._activeAccount.set(account);
+
+    this.eventBus.accountChanged.emit({
+      previousAccount: previous,
+      newAccount: account,
+      timestamp: Date.now(),
+    });
+  }
+
+  async signTransaction(payload: string): Promise<unknown> {
+    const account = this._activeAccount();
+    if (!account) {
+      throw new Error('No active account');
+    }
+
+    const provider = this.providers.get(account.providerId);
+    if (!provider) {
+      throw new Error(`Provider ${account.providerId} not found`);
+    }
+
+    return await provider.signTransaction({
+      accountAddress: account.address,
+      payload,
+      ledgerId: account.ledgerId,
+      networkId: account.networkId,
+    });
+  }
+
+  async submitTransaction(
+    payload: string,
+    options?: {
+      isBatch?: boolean;
+      batchKey?: string;
+      innerTransactions?: Array<{ payload: string; description?: string }>;
+    },
+  ): Promise<unknown> {
+    const account = this._activeAccount();
+    if (!account) {
+      throw new Error('No active account');
+    }
+
+    const provider = this.providers.get(account.providerId);
+    if (!provider) {
+      throw new Error(`Provider ${account.providerId} not found`);
+    }
+
+    return await provider.submitTransaction({
+      accountAddress: account.address,
+      payload,
+      ledgerId: account.ledgerId,
+      networkId: account.networkId,
+      ...options,
+    });
+  }
+
+  async signMessage(message: string, encoding?: 'utf-8' | 'base64'): Promise<unknown> {
+    const account = this._activeAccount();
+    if (!account) {
+      throw new Error('No active account');
+    }
+
+    const provider = this.providers.get(account.providerId);
+    if (!provider) {
+      throw new Error(`Provider ${account.providerId} not found`);
+    }
+
+    return await provider.signMessage({
+      accountAddress: account.address,
+      message,
+      encoding,
+      ledgerId: account.ledgerId,
+      networkId: account.networkId,
+    });
+  }
+
+  async signAndExecuteTransaction(
+    payload: string,
+    options?: Record<string, unknown>,
+  ): Promise<unknown> {
+    const account = this._activeAccount();
+    if (!account) {
+      throw new Error('No active account');
+    }
+
+    const provider = this.providers.get(account.providerId);
+    if (!provider) {
+      throw new Error(`Provider ${account.providerId} not found`);
+    }
+
+    // Check if provider has native signAndExecute support
+    if (typeof provider.signAndExecuteTransaction === 'function') {
+      return await provider.signAndExecuteTransaction({
+        accountAddress: account.address,
+        payload,
+        ledgerId: account.ledgerId,
+        networkId: account.networkId,
+        ...options,
+      });
+    }
+
+    // Fallback: sign then submit
+    const signResult = await provider.signTransaction({
+      accountAddress: account.address,
+      payload,
+      ledgerId: account.ledgerId,
+      networkId: account.networkId,
+      ...options,
+    });
+
+    return await provider.submitTransaction({
+      accountAddress: account.address,
+      payload: signResult.signedPayload || payload,
+      ledgerId: account.ledgerId,
+      networkId: account.networkId,
+      ...options,
+    });
+  }
+
+  getActiveSessions(): Array<{
+    providerId: string;
+    providerType: string;
+    providerName: string;
+    accounts: UnifiedAccount[];
+    metadata: unknown;
+  }> {
+    const sessions: Array<{
+      providerId: string;
+      providerType: string;
+      providerName: string;
+      accounts: UnifiedAccount[];
+      metadata: unknown;
+    }> = [];
+
+    for (const provider of this.providers.values()) {
+      const accounts = provider.accounts();
+
+      if (accounts.length > 0) {
+        if (provider.id === 'walletconnect-v2' && provider.getActiveSessions) {
+          const wcSessions = provider.getActiveSessions();
+          for (const wcSession of wcSessions) {
+            sessions.push({
+              providerId: provider.id,
+              providerType: provider.metadata.type,
+              providerName: provider.metadata.name,
+              accounts: (wcSession as { accounts?: UnifiedAccount[] }).accounts || [],
+              metadata: {
+                sessionKey: (wcSession as { sessionKey?: string }).sessionKey,
+                ledgerId: (wcSession as { ledgerId?: string }).ledgerId,
+                networkId: (wcSession as { networkId?: string }).networkId,
+                topic: (wcSession as { topic?: string }).topic,
+              },
+            });
+          }
+        } else {
+          sessions.push({
+            providerId: provider.id,
+            providerType: provider.metadata.type,
+            providerName: provider.metadata.name,
+            accounts,
+            metadata: {
+              type: provider.metadata.type,
+            },
+          });
+        }
+      }
+    }
+
+    return sessions;
+  }
+
+  async disconnectSession(providerId: string, sessionKey?: string): Promise<void> {
+    const provider = this.providers.get(providerId);
+    if (!provider) {
+      throw new Error(`Provider ${providerId} not found`);
+    }
+
+    if (provider.disconnectSession && sessionKey) {
+      await provider.disconnectSession(sessionKey);
+    } else {
+      await provider.disconnect();
+    }
+
+    this.eventBus.disconnected.emit({
+      providerId,
+      providerType: provider.metadata.type,
+      sessionKey,
+      reason: 'user_initiated',
+      timestamp: Date.now(),
+    });
+
+    // Update active account if needed
+    const active = this._activeAccount();
+    if (active && active.providerId === providerId) {
+      const accounts = this.allAccounts;
+      const nextAccount = accounts.find(
+        (a) =>
+          a.providerId !== providerId ||
+          (sessionKey && (a.metadata as { sessionKey?: string })?.sessionKey !== sessionKey),
+      );
+      this.setActiveAccount(nextAccount || null);
+    }
+  }
+
+  isAnyConnected(): boolean {
+    return this.connectedProviders.length > 0;
+  }
+
+  isConnected(): boolean {
+    return this.isAnyConnected();
+  }
+
+  getAccountById(accountId: string): UnifiedAccount | undefined {
+    return this.allAccounts.find((a) => a.id === accountId);
+  }
+
+  getConnectedLedgers(): string[] {
+    const accounts = this.allAccounts;
+    const ledgerIds = new Set(accounts.map((a) => a.ledgerId).filter(Boolean));
+    return Array.from(ledgerIds);
+  }
+
+  getAccountsByLedger(ledgerId: string): UnifiedAccount[] {
+    return this.allAccounts.filter((a) => a.ledgerId === ledgerId);
+  }
+
+  switchAccount(accountId: string): boolean {
+    const account = this.getAccountById(accountId);
+    if (!account) {
+      return false;
+    }
+    this.setActiveAccount(account);
+    return true;
+  }
+
+  getPrimaryAccountForLedger(ledgerId: string): UnifiedAccount | undefined {
+    return this.allAccounts.find((a) => a.ledgerId === ledgerId);
+  }
+
+  hasAccountsForLedger(ledgerId: string): boolean {
+    return this.getAccountsByLedger(ledgerId).length > 0;
+  }
+}
+
+describe('UnifiedWalletService', () => {
+  let service: TestableUnifiedWalletService;
+  let mockHsuiteProvider: MockWalletProvider;
+  let mockWalletConnectProvider: MockWalletProvider;
+  let mockP2PProvider: MockWalletProvider;
+  let mockEventBus: MockWalletEventBus;
+
+  beforeEach(() => {
+    mockEventBus = new MockWalletEventBus();
+
+    mockHsuiteProvider = new MockWalletProvider('hsuite-native', 'hsuite-native', 'HSuite Native', {
+      supportsReconnect: true,
+      transportState: () => 'nostr-only',
+    });
+
+    mockWalletConnectProvider = new MockWalletProvider(
+      'walletconnect-v2',
+      'walletconnect-v2',
+      'WalletConnect',
+      {
+        supportsSessions: true,
+        supportsSignAndExecute: true,
+      },
+    );
+
+    mockP2PProvider = new MockWalletProvider('mobile-native', 'mobile-native', 'HSuite Mobile', {
+      transportState: () => 'p2p-connected',
+    });
+
+    service = new TestableUnifiedWalletService(
+      mockHsuiteProvider,
+      mockWalletConnectProvider,
+      mockP2PProvider,
+      mockEventBus,
+    );
+  });
+
+  // ==================== INITIALIZATION ====================
+  describe('initialization', () => {
+    it('should create', () => {
+      expect(service).toBeTruthy();
+    });
+
+    it('should auto-register built-in providers', () => {
+      expect(service.getProvider('hsuite-native')).toBe(mockHsuiteProvider);
+      expect(service.getProvider('walletconnect-v2')).toBe(mockWalletConnectProvider);
+      expect(service.getProvider('mobile-native')).toBe(mockP2PProvider);
+    });
+
+    it('should start with no active account', () => {
+      expect(service.activeAccount).toBeNull();
+    });
+
+    it('should start with no connected providers', () => {
+      expect(service.connectedProviders).toHaveLength(0);
+    });
+
+    it('should start with empty accounts list', () => {
+      expect(service.allAccounts).toHaveLength(0);
+    });
+  });
+
+  // ==================== PROVIDER REGISTRATION ====================
+  describe('registerProvider', () => {
+    it('should register a new provider', () => {
+      const customProvider = new MockWalletProvider(
+        'custom-provider',
+        'hsuite-native',
+        'Custom Provider',
+      );
+
+      service.registerProvider(customProvider);
+
+      expect(service.getProvider('custom-provider')).toBe(customProvider);
+    });
+
+    it('should not register duplicate providers', () => {
+      const duplicateProvider = new MockWalletProvider(
+        'hsuite-native',
+        'hsuite-native',
+        'Duplicate',
+      );
+
+      service.registerProvider(duplicateProvider);
+
+      // Should still be the original provider
+      expect(service.getProvider('hsuite-native')?.metadata.name).toBe('HSuite Native');
+    });
+  });
+
+  describe('unregisterProvider', () => {
+    it('should unregister a provider', () => {
+      service.unregisterProvider('hsuite-native');
+
+      expect(service.getProvider('hsuite-native')).toBeUndefined();
+    });
+
+    it('should handle unregistering non-existent provider', () => {
+      // Should not throw
+      expect(() => service.unregisterProvider('non-existent')).not.toThrow();
+    });
+  });
+
+  // ==================== PROVIDER QUERIES ====================
+  describe('getProvider', () => {
+    it('should return provider by ID', () => {
+      const provider = service.getProvider('walletconnect-v2');
+      expect(provider?.id).toBe('walletconnect-v2');
+    });
+
+    it('should return undefined for unknown provider', () => {
+      expect(service.getProvider('unknown')).toBeUndefined();
+    });
+  });
+
+  describe('getProvidersByType', () => {
+    it('should return providers of given type', () => {
+      const providers = service.getProvidersByType('hsuite-native');
+      expect(providers).toHaveLength(1);
+      expect(providers[0].id).toBe('hsuite-native');
+    });
+
+    it('should return empty array for type with no providers', () => {
+      service.unregisterProvider('hsuite-native');
+      const providers = service.getProvidersByType('hsuite-native');
+      expect(providers).toHaveLength(0);
+    });
+  });
+
+  describe('getProviderSummaries', () => {
+    it('should return summaries for all providers', () => {
+      const summaries = service.getProviderSummaries();
+
+      expect(summaries).toHaveLength(3);
+      expect(summaries.map((s) => s.id)).toContain('hsuite-native');
+      expect(summaries.map((s) => s.id)).toContain('walletconnect-v2');
+      expect(summaries.map((s) => s.id)).toContain('mobile-native');
+    });
+
+    it('should include correct provider metadata', () => {
+      const summaries = service.getProviderSummaries();
+      const hsuiteSummary = summaries.find((s) => s.id === 'hsuite-native');
+
+      expect(hsuiteSummary?.name).toBe('HSuite Native');
+      expect(hsuiteSummary?.providerType).toBe('hsuite-native');
+      expect(hsuiteSummary?.supportsReconnect).toBe(true);
+    });
+
+    it('should include account list', () => {
+      const account = createMockAccount();
+      mockHsuiteProvider.setAccounts([account]);
+
+      const summaries = service.getProviderSummaries();
+      const hsuiteSummary = summaries.find((s) => s.id === 'hsuite-native');
+
+      expect(hsuiteSummary?.accounts).toHaveLength(1);
+    });
+  });
+
+  // ==================== CONNECTION MANAGEMENT ====================
+  describe('connect', () => {
+    it('should connect to provider', async () => {
+      const config: ConnectionConfig = {
+        type: 'hsuite-native',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'hedera:testnet',
+      };
+
+      await service.connect('hsuite-native', config);
+
+      expect(mockHsuiteProvider.connect).toHaveBeenCalledWith(config);
+    });
+
+    it('should throw error for unknown provider', async () => {
+      const config: ConnectionConfig = {
+        type: 'hsuite-native',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'hedera:testnet',
+      };
+
+      await expect(service.connect('unknown', config)).rejects.toThrow(
+        'Provider unknown not found',
+      );
+    });
+
+    it('should emit connected event', async () => {
+      const config: ConnectionConfig = {
+        type: 'hsuite-native',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'hedera:testnet',
+      };
+
+      await service.connect('hsuite-native', config);
+
+      expect(mockEventBus.connected.emit).toHaveBeenCalledWith(
+        expect.objectContaining({
+          providerId: 'hsuite-native',
+          providerType: 'hsuite-native',
+        }),
+      );
+    });
+
+    it('should emit accountsUpdated event', async () => {
+      const config: ConnectionConfig = {
+        type: 'hsuite-native',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'hedera:testnet',
+      };
+
+      await service.connect('hsuite-native', config);
+
+      expect(mockEventBus.accountsUpdated.emit).toHaveBeenCalled();
+    });
+
+    it('should auto-select first account after connect', async () => {
+      const account = createMockAccount();
+      mockHsuiteProvider.setAccounts([account]);
+
+      const config: ConnectionConfig = {
+        type: 'hsuite-native',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'hedera:testnet',
+      };
+
+      await service.connect('hsuite-native', config);
+
+      expect(service.activeAccount).toEqual(account);
+    });
+  });
+
+  describe('disconnect', () => {
+    it('should disconnect from provider', async () => {
+      await service.disconnect('hsuite-native');
+
+      expect(mockHsuiteProvider.disconnect).toHaveBeenCalled();
+    });
+
+    it('should throw error for unknown provider', async () => {
+      await expect(service.disconnect('unknown')).rejects.toThrow('Provider unknown not found');
+    });
+
+    it('should clear active account if it belonged to disconnected provider', async () => {
+      const account = createMockAccount({ providerId: 'hsuite-native' });
+      mockHsuiteProvider.setAccounts([account]);
+      mockHsuiteProvider.setStatus('connected');
+      service.setActiveAccount(account);
+
+      await service.disconnect('hsuite-native');
+
+      expect(service.activeAccount).toBeNull();
+    });
+
+    it('should switch to another account if available', async () => {
+      const hsuiteAccount = createMockAccount({ id: 'hsuite-1', providerId: 'hsuite-native' });
+      const wcAccount = createMockAccount({ id: 'wc-1', providerId: 'walletconnect-v2' });
+
+      mockHsuiteProvider.setAccounts([hsuiteAccount]);
+      mockWalletConnectProvider.setAccounts([wcAccount]);
+      mockHsuiteProvider.setStatus('connected');
+      mockWalletConnectProvider.setStatus('connected');
+      service.setActiveAccount(hsuiteAccount);
+
+      await service.disconnect('hsuite-native');
+
+      expect(service.activeAccount).toEqual(wcAccount);
+    });
+  });
+
+  describe('disconnectAll', () => {
+    it('should disconnect all connected providers', async () => {
+      mockHsuiteProvider.setStatus('connected');
+      mockWalletConnectProvider.setStatus('connected');
+
+      await service.disconnectAll();
+
+      expect(mockHsuiteProvider.disconnect).toHaveBeenCalled();
+      expect(mockWalletConnectProvider.disconnect).toHaveBeenCalled();
+    });
+
+    it('should clear active account', async () => {
+      const account = createMockAccount();
+      service.setActiveAccount(account);
+
+      await service.disconnectAll();
+
+      expect(service.activeAccount).toBeNull();
+    });
+
+    it('should only disconnect connected providers', async () => {
+      mockHsuiteProvider.setStatus('connected');
+      mockWalletConnectProvider.setStatus('disconnected');
+
+      await service.disconnectAll();
+
+      expect(mockHsuiteProvider.disconnect).toHaveBeenCalled();
+      expect(mockWalletConnectProvider.disconnect).not.toHaveBeenCalled();
+    });
+  });
+
+  // ==================== RECONNECTION ====================
+  describe('reconnectProvider', () => {
+    it('should attempt reconnection on supported providers', async () => {
+      const result = await service.reconnectProvider('hsuite-native');
+
+      expect(mockHsuiteProvider.attemptReconnect).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+
+    it('should return false for providers without reconnect support', async () => {
+      const result = await service.reconnectProvider('mobile-native');
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false for unknown provider', async () => {
+      const result = await service.reconnectProvider('unknown');
+
+      expect(result).toBe(false);
+    });
+
+    it('should handle reconnection failure', async () => {
+      mockHsuiteProvider.attemptReconnect!.mockRejectedValueOnce(new Error('Failed'));
+
+      const result = await service.reconnectProvider('hsuite-native');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  // ==================== ACCOUNT MANAGEMENT ====================
+  describe('setActiveAccount', () => {
+    it('should set active account', () => {
+      const account = createMockAccount();
+
+      service.setActiveAccount(account);
+
+      expect(service.activeAccount).toEqual(account);
+    });
+
+    it('should emit accountChanged event', () => {
+      const account = createMockAccount();
+
+      service.setActiveAccount(account);
+
+      expect(mockEventBus.accountChanged.emit).toHaveBeenCalledWith(
+        expect.objectContaining({
+          previousAccount: null,
+          newAccount: account,
+        }),
+      );
+    });
+
+    it('should include previous account in event', () => {
+      const account1 = createMockAccount({ id: 'account-1' });
+      const account2 = createMockAccount({ id: 'account-2' });
+
+      service.setActiveAccount(account1);
+      service.setActiveAccount(account2);
+
+      expect(mockEventBus.accountChanged.emit).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          previousAccount: account1,
+          newAccount: account2,
+        }),
+      );
+    });
+
+    it('should allow setting to null', () => {
+      const account = createMockAccount();
+      service.setActiveAccount(account);
+
+      service.setActiveAccount(null);
+
+      expect(service.activeAccount).toBeNull();
+    });
+  });
+
+  describe('switchAccount', () => {
+    it('should switch to account by ID', () => {
+      const account = createMockAccount({ id: 'target-account' });
+      mockHsuiteProvider.setAccounts([account]);
+
+      const result = service.switchAccount('target-account');
+
+      expect(result).toBe(true);
+      expect(service.activeAccount).toEqual(account);
+    });
+
+    it('should return false for unknown account', () => {
+      const result = service.switchAccount('unknown-account');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getAccountById', () => {
+    it('should return account by ID', () => {
+      const account = createMockAccount({ id: 'test-account' });
+      mockHsuiteProvider.setAccounts([account]);
+
+      const result = service.getAccountById('test-account');
+
+      expect(result).toEqual(account);
+    });
+
+    it('should return undefined for unknown ID', () => {
+      const result = service.getAccountById('unknown');
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getConnectedLedgers', () => {
+    it('should return unique ledger IDs', () => {
+      mockHsuiteProvider.setAccounts([
+        createMockAccount({ id: 'h1', ledgerId: 'hedera' }),
+        createMockAccount({ id: 'h2', ledgerId: 'hedera' }),
+      ]);
+      mockWalletConnectProvider.setAccounts([createMockAccount({ id: 'x1', ledgerId: 'xrpl' })]);
+
+      const ledgers = service.getConnectedLedgers();
+
+      expect(ledgers).toHaveLength(2);
+      expect(ledgers).toContain('hedera');
+      expect(ledgers).toContain('xrpl');
+    });
+
+    it('should return empty array when no accounts', () => {
+      const ledgers = service.getConnectedLedgers();
+
+      expect(ledgers).toHaveLength(0);
+    });
+  });
+
+  describe('getAccountsByLedger', () => {
+    it('should filter accounts by ledger', () => {
+      mockHsuiteProvider.setAccounts([createMockAccount({ id: 'h1', ledgerId: 'hedera' })]);
+      mockWalletConnectProvider.setAccounts([createMockAccount({ id: 'x1', ledgerId: 'xrpl' })]);
+
+      const hederaAccounts = service.getAccountsByLedger('hedera');
+      const xrplAccounts = service.getAccountsByLedger('xrpl');
+
+      expect(hederaAccounts).toHaveLength(1);
+      expect(hederaAccounts[0].id).toBe('h1');
+      expect(xrplAccounts).toHaveLength(1);
+      expect(xrplAccounts[0].id).toBe('x1');
+    });
+  });
+
+  describe('getPrimaryAccountForLedger', () => {
+    it('should return first account for ledger', () => {
+      mockHsuiteProvider.setAccounts([
+        createMockAccount({ id: 'h1', ledgerId: 'hedera' }),
+        createMockAccount({ id: 'h2', ledgerId: 'hedera' }),
+      ]);
+
+      const primary = service.getPrimaryAccountForLedger('hedera');
+
+      expect(primary?.id).toBe('h1');
+    });
+
+    it('should return undefined when no accounts for ledger', () => {
+      const primary = service.getPrimaryAccountForLedger('xrpl');
+
+      expect(primary).toBeUndefined();
+    });
+  });
+
+  describe('hasAccountsForLedger', () => {
+    it('should return true when accounts exist', () => {
+      mockHsuiteProvider.setAccounts([createMockAccount({ ledgerId: 'hedera' })]);
+
+      expect(service.hasAccountsForLedger('hedera')).toBe(true);
+    });
+
+    it('should return false when no accounts', () => {
+      expect(service.hasAccountsForLedger('xrpl')).toBe(false);
+    });
+  });
+
+  // ==================== CONNECTION STATUS ====================
+  describe('isConnected / isAnyConnected', () => {
+    it('should return false when no providers connected', () => {
+      expect(service.isConnected()).toBe(false);
+      expect(service.isAnyConnected()).toBe(false);
+    });
+
+    it('should return true when any provider is connected', () => {
+      mockHsuiteProvider.setStatus('connected');
+
+      expect(service.isConnected()).toBe(true);
+      expect(service.isAnyConnected()).toBe(true);
+    });
+  });
+
+  describe('connectedProviders', () => {
+    it('should return list of connected providers', () => {
+      mockHsuiteProvider.setStatus('connected');
+      mockWalletConnectProvider.setStatus('connected');
+
+      const connected = service.connectedProviders;
+
+      expect(connected).toHaveLength(2);
+    });
+
+    it('should return empty array when none connected', () => {
+      expect(service.connectedProviders).toHaveLength(0);
+    });
+  });
+
+  // ==================== TRANSPORT STATE ====================
+  describe('transportState', () => {
+    it('should return idle when no native providers connected', () => {
+      expect(service.transportState).toBe('idle');
+    });
+
+    it('should return hsuite transport state when connected', () => {
+      mockHsuiteProvider.setStatus('connected');
+
+      expect(service.transportState).toBe('nostr-only');
+    });
+
+    it('should return p2p transport state when connected', () => {
+      mockP2PProvider.setStatus('connected');
+
+      expect(service.transportState).toBe('p2p-connected');
+    });
+
+    it('should prioritize hsuite over p2p', () => {
+      mockHsuiteProvider.setStatus('connected');
+      mockP2PProvider.setStatus('connected');
+
+      expect(service.transportState).toBe('nostr-only');
+    });
+  });
+
+  // ==================== TRANSACTION OPERATIONS ====================
+  describe('signTransaction', () => {
+    it('should sign transaction with active account provider', async () => {
+      const account = createMockAccount({ providerId: 'hsuite-native' });
+      mockHsuiteProvider.setAccounts([account]);
+      service.setActiveAccount(account);
+
+      await service.signTransaction('payload-123');
+
+      expect(mockHsuiteProvider.signTransaction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          accountAddress: account.address,
+          payload: 'payload-123',
+          ledgerId: account.ledgerId,
+          networkId: account.networkId,
+        }),
+      );
+    });
+
+    it('should throw when no active account', async () => {
+      await expect(service.signTransaction('payload')).rejects.toThrow('No active account');
+    });
+
+    it('should throw when provider not found', async () => {
+      const account = createMockAccount({ providerId: 'non-existent' });
+      service.setActiveAccount(account);
+
+      await expect(service.signTransaction('payload')).rejects.toThrow(
+        'Provider non-existent not found',
+      );
+    });
+  });
+
+  describe('submitTransaction', () => {
+    it('should submit transaction with active account provider', async () => {
+      const account = createMockAccount({ providerId: 'hsuite-native' });
+      mockHsuiteProvider.setAccounts([account]);
+      service.setActiveAccount(account);
+
+      await service.submitTransaction('payload-123');
+
+      expect(mockHsuiteProvider.submitTransaction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          accountAddress: account.address,
+          payload: 'payload-123',
+        }),
+      );
+    });
+
+    it('should pass batch options', async () => {
+      const account = createMockAccount({ providerId: 'hsuite-native' });
+      mockHsuiteProvider.setAccounts([account]);
+      service.setActiveAccount(account);
+
+      const options = {
+        isBatch: true,
+        batchKey: 'batch-key-123',
+        innerTransactions: [{ payload: 'inner-tx' }],
+      };
+
+      await service.submitTransaction('payload', options);
+
+      expect(mockHsuiteProvider.submitTransaction).toHaveBeenCalledWith(
+        expect.objectContaining(options),
+      );
+    });
+
+    it('should throw when no active account', async () => {
+      await expect(service.submitTransaction('payload')).rejects.toThrow('No active account');
+    });
+  });
+
+  describe('signMessage', () => {
+    it('should sign message with active account provider', async () => {
+      const account = createMockAccount({ providerId: 'hsuite-native' });
+      mockHsuiteProvider.setAccounts([account]);
+      service.setActiveAccount(account);
+
+      await service.signMessage('Hello, World!', 'utf-8');
+
+      expect(mockHsuiteProvider.signMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          accountAddress: account.address,
+          message: 'Hello, World!',
+          encoding: 'utf-8',
+        }),
+      );
+    });
+
+    it('should throw when no active account', async () => {
+      await expect(service.signMessage('message')).rejects.toThrow('No active account');
+    });
+  });
+
+  describe('signAndExecuteTransaction', () => {
+    it('should use native signAndExecute when available', async () => {
+      const account = createMockAccount({ providerId: 'walletconnect-v2' });
+      mockWalletConnectProvider.setAccounts([account]);
+      service.setActiveAccount(account);
+
+      await service.signAndExecuteTransaction('payload-123');
+
+      expect(mockWalletConnectProvider.signAndExecuteTransaction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          accountAddress: account.address,
+          payload: 'payload-123',
+        }),
+      );
+    });
+
+    it('should fallback to sign then submit when not available', async () => {
+      const account = createMockAccount({ providerId: 'hsuite-native' });
+      mockHsuiteProvider.setAccounts([account]);
+      service.setActiveAccount(account);
+
+      await service.signAndExecuteTransaction('payload-123');
+
+      expect(mockHsuiteProvider.signTransaction).toHaveBeenCalled();
+      expect(mockHsuiteProvider.submitTransaction).toHaveBeenCalled();
+    });
+
+    it('should throw when no active account', async () => {
+      await expect(service.signAndExecuteTransaction('payload')).rejects.toThrow(
+        'No active account',
+      );
+    });
+  });
+
+  // ==================== SESSION MANAGEMENT ====================
+  describe('getActiveSessions', () => {
+    it('should return sessions from all providers', () => {
+      const hsuiteAccount = createMockAccount({ providerId: 'hsuite-native' });
+      mockHsuiteProvider.setAccounts([hsuiteAccount]);
+
+      const sessions = service.getActiveSessions();
+
+      expect(sessions).toHaveLength(1);
+      expect(sessions[0].providerId).toBe('hsuite-native');
+    });
+
+    it('should include WalletConnect sessions with metadata', () => {
+      const wcAccount = createMockAccount({ providerId: 'walletconnect-v2' });
+      mockWalletConnectProvider.setAccounts([wcAccount]);
+      mockWalletConnectProvider.getActiveSessions!.mockReturnValue([
+        {
+          sessionKey: 'session-123',
+          ledgerId: 'hedera',
+          networkId: 'hedera:testnet',
+          topic: 'topic-abc',
+          accounts: [wcAccount],
+        },
+      ]);
+
+      const sessions = service.getActiveSessions();
+
+      expect(sessions).toHaveLength(1);
+      expect(sessions[0].metadata).toEqual(
+        expect.objectContaining({
+          sessionKey: 'session-123',
+          topic: 'topic-abc',
+        }),
+      );
+    });
+
+    it('should return empty array when no accounts', () => {
+      const sessions = service.getActiveSessions();
+
+      expect(sessions).toHaveLength(0);
+    });
+  });
+
+  describe('disconnectSession', () => {
+    it('should use provider disconnectSession when available', async () => {
+      mockWalletConnectProvider.setAccounts([
+        createMockAccount({ providerId: 'walletconnect-v2' }),
+      ]);
+
+      await service.disconnectSession('walletconnect-v2', 'session-key');
+
+      expect(mockWalletConnectProvider.disconnectSession).toHaveBeenCalledWith('session-key');
+    });
+
+    it('should fallback to provider disconnect when sessionKey not provided', async () => {
+      await service.disconnectSession('walletconnect-v2');
+
+      expect(mockWalletConnectProvider.disconnect).toHaveBeenCalled();
+    });
+
+    it('should emit disconnected event', async () => {
+      await service.disconnectSession('hsuite-native');
+
+      expect(mockEventBus.disconnected.emit).toHaveBeenCalledWith(
+        expect.objectContaining({
+          providerId: 'hsuite-native',
+          reason: 'user_initiated',
+        }),
+      );
+    });
+
+    it('should throw for unknown provider', async () => {
+      await expect(service.disconnectSession('unknown')).rejects.toThrow(
+        'Provider unknown not found',
+      );
+    });
+
+    it('should update active account if needed', async () => {
+      const account = createMockAccount({ providerId: 'hsuite-native' });
+      mockHsuiteProvider.setAccounts([account]);
+      service.setActiveAccount(account);
+
+      await service.disconnectSession('hsuite-native');
+
+      expect(service.activeAccount).toBeNull();
+    });
+  });
+
+  // ==================== ALL ACCOUNTS ====================
+  describe('allAccounts', () => {
+    it('should aggregate accounts from all providers', () => {
+      mockHsuiteProvider.setAccounts([
+        createMockAccount({ id: 'h1', providerId: 'hsuite-native' }),
+        createMockAccount({ id: 'h2', providerId: 'hsuite-native' }),
+      ]);
+      mockWalletConnectProvider.setAccounts([
+        createMockAccount({ id: 'wc1', providerId: 'walletconnect-v2' }),
+      ]);
+
+      const accounts = service.allAccounts;
+
+      expect(accounts).toHaveLength(3);
+    });
+
+    it('should return empty array when no accounts', () => {
+      expect(service.allAccounts).toHaveLength(0);
+    });
+  });
+});