@hsuite/native-connect-angular 1.0.0

package/src/lib/providers/mobile-native/mobile-native.provider.spec.ts

@@ -0,0 +1,19 @@
+/**
+ * @file mobile-native.provider.spec.ts
+ * @description Unit tests for MobileNativeProvider
+ *
+ * @compodoc
+ * These tests use direct instantiation instead of Angular TestBed
+ * since Vitest doesn't support Angular's decorator-based DI metadata.
+ *
+ * NOTE: These tests are skipped until MobileNativeProvider implementation is complete.
+ */
+
+import { describe, it, expect } from 'vitest';
+
+// Skip all tests - implementation not yet available
+describe.skip('MobileNativeProvider', () => {
+  it('placeholder - implementation pending', () => {
+    expect(true).toBe(true);
+  });
+});

package/src/lib/providers/p2p-native/index.ts

@@ -0,0 +1,30 @@
+/**
+ * HSuite Native Connect
+ * Copyright 2024-2025 HSuite (https://hsuite.finance)
+ *
+ * SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+ *
+ * This file is part of HSuite Native Connect. For commercial licensing,
+ * visit https://hsuite.finance/licensing
+ */
+
+/**
+ * @file index.ts
+ * @description P2P Native Provider exports
+ *
+ * Exports for P2P Native connection components.
+ */
+
+export {
+  P2PNativeProvider,
+  type PairingOfferResult,
+  type P2PNativeConnectionState,
+} from './p2p-native.provider';
+
+export {
+  P2PSessionManager,
+  type P2PSession,
+  type CreateOfferOptions,
+  type CreateOfferResult,
+  type P2PConnectionState,
+} from './p2p-session-manager';

package/src/lib/providers/p2p-native/p2p-native.provider.spec.ts

@@ -0,0 +1,523 @@
+/**
+ * @file p2p-native.provider.spec.ts
+ * @description Unit tests for P2PNativeProvider
+ *
+ * @compodoc
+ * These tests use direct instantiation instead of Angular TestBed
+ * since Vitest doesn't support Angular's decorator-based DI metadata.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { P2PNativeProvider, type PairingOfferResult } from './p2p-native.provider';
+import type { P2PSession } from './p2p-session-manager';
+
+/**
+ * Mock MobileNativeSessionManager for testing
+ */
+class MockMobileNativeSessionManager {
+  private connectedCallbacks: Array<(session: P2PSession) => void> = [];
+  private disconnectedCallbacks: Array<() => void> = [];
+  private errorCallbacks: Array<(error: Error) => void> = [];
+  private accountsChangedCallbacks: Array<(accounts: unknown[]) => void> = [];
+
+  setNgZone = vi.fn();
+
+  createPairingOffer = vi.fn().mockResolvedValue({
+    qrData: 'hsc:connect?i=test-offer-data',
+  });
+
+  cancelPairingOffer = vi.fn().mockResolvedValue(undefined);
+  terminateSession = vi.fn().mockResolvedValue(undefined);
+
+  signTransaction = vi.fn().mockResolvedValue({
+    signedPayload: 'signed-payload',
+    signature: 'signature-123',
+  });
+
+  submitTransaction = vi.fn().mockResolvedValue({
+    transactionId: '0.0.123@1234567890.123456789',
+    transactionHash: 'abc123',
+  });
+
+  signMessage = vi.fn().mockResolvedValue({
+    signature: 'message-signature',
+    publicKey: 'public-key-123',
+  });
+
+  onConnected(callback: (session: P2PSession) => void): void {
+    this.connectedCallbacks.push(callback);
+  }
+
+  onDisconnected(callback: () => void): void {
+    this.disconnectedCallbacks.push(callback);
+  }
+
+  onError(callback: (error: Error) => void): void {
+    this.errorCallbacks.push(callback);
+  }
+
+  onAccountsChanged(callback: (accounts: unknown[]) => void): void {
+    this.accountsChangedCallbacks.push(callback);
+  }
+
+  // Test helpers
+  simulateConnected(session: P2PSession): void {
+    this.connectedCallbacks.forEach((cb) => cb(session));
+  }
+
+  simulateDisconnected(): void {
+    this.disconnectedCallbacks.forEach((cb) => cb());
+  }
+
+  simulateError(error: Error): void {
+    this.errorCallbacks.forEach((cb) => cb(error));
+  }
+
+  simulateAccountsChanged(accounts: unknown[]): void {
+    this.accountsChangedCallbacks.forEach((cb) => cb(accounts));
+  }
+}
+
+/**
+ * Create a test instance of P2PNativeProvider with mock dependencies.
+ * This bypasses Angular DI which doesn't work properly in Vitest.
+ */
+function createTestProvider(mockSessionManager: MockMobileNativeSessionManager): P2PNativeProvider {
+  // Mock NgZone — the provider wraps async session callbacks in ngZone.run()
+  // to make signal updates trigger Angular change detection.
+  const mockNgZone = { run: <T>(fn: () => T) => fn() };
+  const provider = new (P2PNativeProvider as any)(mockSessionManager, mockNgZone);
+  return provider;
+}
+
+describe('P2PNativeProvider', () => {
+  let provider: P2PNativeProvider;
+  let mockSessionManager: MockMobileNativeSessionManager;
+
+  beforeEach(() => {
+    // Clear localStorage to prevent persisted session restoration
+    localStorage.clear();
+
+    mockSessionManager = new MockMobileNativeSessionManager();
+    provider = createTestProvider(mockSessionManager);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    localStorage.clear();
+  });
+
+  // ========== Initialization Tests ==========
+
+  describe('initialization', () => {
+    it('should create', () => {
+      expect(provider).toBeTruthy();
+    });
+
+    it('should have correct id', () => {
+      expect(provider.id).toBe('mobile-native');
+    });
+
+    it('should have correct metadata', () => {
+      expect(provider.metadata.name).toBe('HSuite Mobile');
+      expect(provider.metadata.type).toBe('mobile-native');
+      expect(provider.metadata.icon).toBe('phone-portrait-outline');
+      expect(provider.metadata.description).toBe('Connect via QR code (P2P)');
+    });
+
+    it('should start in disconnected state', () => {
+      expect(provider.status()).toBe('disconnected');
+      expect(provider.connectionState()).toBe('disconnected');
+    });
+
+    it('should start with empty accounts', () => {
+      expect(provider.accounts()).toEqual([]);
+    });
+
+    it('should start with no error', () => {
+      expect(provider.error()).toBeNull();
+    });
+  });
+
+  // ========== Availability Tests ==========
+
+  describe('isAvailable', () => {
+    it('should return true when WebRTC is available', async () => {
+      const originalRTC = globalThis.RTCPeerConnection;
+      globalThis.RTCPeerConnection = vi.fn() as unknown as typeof RTCPeerConnection;
+
+      const available = await provider.isAvailable();
+      expect(available).toBe(true);
+
+      globalThis.RTCPeerConnection = originalRTC;
+    });
+
+    it('should return false when WebRTC is not available', async () => {
+      const originalRTC = globalThis.RTCPeerConnection;
+      // @ts-expect-error - Intentionally removing for test
+      delete globalThis.RTCPeerConnection;
+
+      const available = await provider.isAvailable();
+      expect(available).toBe(false);
+
+      globalThis.RTCPeerConnection = originalRTC;
+    });
+  });
+
+  // ========== Pairing Offer Tests ==========
+
+  describe('createPairingOffer', () => {
+    it('should generate QR data', async () => {
+      const result = await provider.createPairingOffer({
+        type: 'mobile-native',
+        networkId: 'testnet',
+        ledgerId: 'hedera',
+      });
+
+      expect(result.qrData).toBe('hsc:connect?i=test-offer-data');
+      expect(result.expiresAt).toBeGreaterThan(Date.now());
+    });
+
+    it('should update connection state to awaiting_scan', async () => {
+      await provider.createPairingOffer({
+        type: 'mobile-native',
+        networkId: 'testnet',
+      });
+
+      expect(provider.connectionState()).toBe('awaiting_scan');
+      expect(provider.status()).toBe('connecting');
+    });
+
+    it('should store pairing offer', async () => {
+      await provider.createPairingOffer({
+        type: 'mobile-native',
+        networkId: 'testnet',
+      });
+
+      expect(provider.hasPairingOffer()).toBe(true);
+      expect(provider.pairingOffer()?.qrData).toBe('hsc:connect?i=test-offer-data');
+    });
+
+    it('should use provided config values', async () => {
+      await provider.createPairingOffer({
+        type: 'mobile-native',
+        appId: 'custom-app',
+        appName: 'Custom App',
+        ledgerId: 'xrpl',
+        networkId: 'mainnet',
+      });
+
+      expect(mockSessionManager.createPairingOffer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          appId: 'custom-app',
+          appName: 'Custom App',
+          ledgerId: 'xrpl',
+          networkId: 'mainnet',
+        }),
+      );
+    });
+
+    it('should handle errors gracefully', async () => {
+      mockSessionManager.createPairingOffer.mockRejectedValueOnce(new Error('Network error'));
+
+      await expect(
+        provider.createPairingOffer({
+          type: 'mobile-native',
+          networkId: 'testnet',
+        }),
+      ).rejects.toThrow('Network error');
+
+      expect(provider.connectionState()).toBe('error');
+      expect(provider.status()).toBe('error');
+      expect(provider.error()).toBe('Network error');
+    });
+  });
+
+  // ========== Refresh Offer Tests ==========
+
+  describe('refreshPairingOffer', () => {
+    it('should cancel existing offer and create new one', async () => {
+      // First offer
+      await provider.createPairingOffer({
+        type: 'mobile-native',
+        networkId: 'testnet',
+      });
+
+      // Refresh
+      mockSessionManager.createPairingOffer.mockResolvedValueOnce({
+        qrData: 'hsc:connect?i=refreshed-offer',
+      });
+
+      const result = await provider.refreshPairingOffer({
+        type: 'mobile-native',
+        networkId: 'testnet',
+      });
+
+      expect(mockSessionManager.cancelPairingOffer).toHaveBeenCalled();
+      expect(result.qrData).toBe('hsc:connect?i=refreshed-offer');
+    });
+  });
+
+  // ========== Session Event Tests ==========
+
+  describe('session events', () => {
+    it('should update status when session connects', () => {
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [
+          { address: '0.0.123', ledgerId: 'hedera' },
+          { address: '0.0.456', ledgerId: 'hedera' },
+        ],
+        permissions: ['sign', 'submit'],
+        connectedAt: Date.now(),
+      });
+
+      expect(provider.connectionState()).toBe('connected');
+      expect(provider.status()).toBe('connected');
+      expect(provider.accounts().length).toBe(2);
+      expect(provider.hasPairingOffer()).toBe(false);
+    });
+
+    it('should update status when session disconnects', () => {
+      // First connect
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [],
+        permissions: [],
+        connectedAt: Date.now(),
+      });
+
+      // Then disconnect
+      mockSessionManager.simulateDisconnected();
+
+      expect(provider.connectionState()).toBe('disconnected');
+      expect(provider.status()).toBe('disconnected');
+      expect(provider.accounts()).toEqual([]);
+    });
+
+    it('should handle session errors', () => {
+      mockSessionManager.simulateError(new Error('Connection lost'));
+
+      expect(provider.connectionState()).toBe('error');
+      expect(provider.status()).toBe('error');
+      expect(provider.error()).toBe('Connection lost');
+    });
+
+    it('should update accounts when changed', () => {
+      mockSessionManager.simulateAccountsChanged([{ address: '0.0.789', ledgerId: 'hedera' }]);
+
+      expect(provider.accounts().length).toBe(1);
+      expect(provider.accounts()[0].address).toBe('0.0.789');
+    });
+  });
+
+  // ========== Disconnect Tests ==========
+
+  describe('disconnect', () => {
+    it('should terminate session and clear state', async () => {
+      // First connect
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [{ address: '0.0.123', ledgerId: 'hedera' }],
+        permissions: ['sign'],
+        connectedAt: Date.now(),
+      });
+
+      // Disconnect
+      await provider.disconnect();
+
+      expect(mockSessionManager.terminateSession).toHaveBeenCalled();
+      expect(provider.status()).toBe('disconnected');
+      expect(provider.accounts()).toEqual([]);
+      expect(provider.error()).toBeNull();
+    });
+  });
+
+  // ========== Transaction Tests ==========
+
+  describe('signTransaction', () => {
+    beforeEach(() => {
+      // Connect first
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [{ address: '0.0.123', ledgerId: 'hedera' }],
+        permissions: ['sign'],
+        connectedAt: Date.now(),
+      });
+    });
+
+    it('should sign transaction when connected', async () => {
+      const result = await provider.signTransaction({
+        accountAddress: '0.0.123',
+        payload: 'transaction-bytes',
+      });
+
+      expect(result.signedPayload).toBe('signed-payload');
+      expect(result.signature).toBe('signature-123');
+    });
+
+    it('should throw when not connected', async () => {
+      // Disconnect
+      mockSessionManager.simulateDisconnected();
+
+      await expect(
+        provider.signTransaction({
+          accountAddress: '0.0.123',
+          payload: 'transaction-bytes',
+        }),
+      ).rejects.toThrow('Not connected to wallet');
+    });
+  });
+
+  describe('submitTransaction', () => {
+    beforeEach(() => {
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [{ address: '0.0.123', ledgerId: 'hedera' }],
+        permissions: ['sign', 'submit'],
+        connectedAt: Date.now(),
+      });
+    });
+
+    it('should submit transaction when connected', async () => {
+      const result = await provider.submitTransaction({
+        accountAddress: '0.0.123',
+        payload: 'transaction-bytes',
+      });
+
+      expect(result.transactionId).toBe('0.0.123@1234567890.123456789');
+      expect(result.transactionHash).toBe('abc123');
+    });
+  });
+
+  describe('signMessage', () => {
+    beforeEach(() => {
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [{ address: '0.0.123', ledgerId: 'hedera' }],
+        permissions: ['sign'],
+        connectedAt: Date.now(),
+      });
+    });
+
+    it('should sign message when connected', async () => {
+      const result = await provider.signMessage({
+        accountAddress: '0.0.123',
+        message: 'Hello, World!',
+      });
+
+      expect(result.signature).toBe('message-signature');
+      expect(result.publicKey).toBe('public-key-123');
+    });
+  });
+
+  // ========== Computed Properties Tests ==========
+
+  describe('computed properties', () => {
+    it('isAwaitingScan should be true when awaiting scan', async () => {
+      expect(provider.isAwaitingScan()).toBe(false);
+
+      await provider.createPairingOffer({
+        type: 'mobile-native',
+        networkId: 'testnet',
+      });
+
+      expect(provider.isAwaitingScan()).toBe(true);
+    });
+
+    it('getPrimaryAccount should return first account', () => {
+      expect(provider.getPrimaryAccount()).toBeNull();
+
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [
+          { address: '0.0.111', ledgerId: 'hedera' },
+          { address: '0.0.222', ledgerId: 'hedera' },
+        ],
+        permissions: [],
+        connectedAt: Date.now(),
+      });
+
+      const primary = provider.getPrimaryAccount();
+      expect(primary?.address).toBe('0.0.111');
+    });
+
+    it('isConnected should return true when connected', () => {
+      expect(provider.isConnected()).toBe(false);
+
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [],
+        permissions: [],
+        connectedAt: Date.now(),
+      });
+
+      expect(provider.isConnected()).toBe(true);
+    });
+  });
+
+  // ========== Callback Tests ==========
+
+  describe('onPeerConnected', () => {
+    it('should call callback when peer connects', () => {
+      const callback = vi.fn();
+      provider.onPeerConnected(callback);
+
+      mockSessionManager.simulateConnected({
+        id: 'session-1',
+        sessionId: 'session-123',
+        appId: 'test-app',
+        appName: 'Test App',
+        ledgerId: 'hedera',
+        networkId: 'testnet',
+        accounts: [],
+        permissions: [],
+        connectedAt: Date.now(),
+      });
+
+      // The callback is registered on the session manager, not directly called
+      // This tests that the registration mechanism works
+      expect(provider.isConnected()).toBe(true);
+    });
+  });
+});