@hsuite/native-connect-angular 1.0.0

package/src/lib/providers/walletconnect/signers/signer-factory.ts

@@ -0,0 +1,120 @@
+/**
+ * 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 signer-factory.ts
+ * @description Factory for creating and managing WalletConnect signers
+ *
+ * Implements the Factory Pattern for creating ledger-specific signers.
+ * Maintains a registry of available signers and provides type-safe access.
+ *
+ * This design allows easy extension - new ledgers can be added by:
+ * 1. Implementing IWalletConnectSigner interface
+ * 2. Registering the signer with SignerFactory
+ */
+
+import { getLogger } from '@hsuite/native-connect-sdk';
+
+import type { IWalletConnectSigner } from '../core/base-signer.interface';
+
+import { HederaSigner } from './hedera-signer';
+import { XrplSigner } from './xrpl-signer';
+
+const logger = getLogger().scoped?.('SignerFactory') ?? getLogger();
+
+/**
+ * Factory class for creating and managing WalletConnect signers.
+ *
+ * Features:
+ * - Singleton signer instances for each ledger (performance optimization)
+ * - Type-safe ledger ID validation
+ * - Extensible registration system for custom signers
+ */
+export class SignerFactory {
+  /**
+   * Registry of available signers.
+   * Each ledger ID maps to a singleton signer instance.
+   */
+  private static signers = new Map<string, IWalletConnectSigner>([
+    ['hedera', new HederaSigner()],
+    ['xrpl', new XrplSigner()],
+  ]);
+
+  /**
+   * Get a signer for the specified ledger.
+   *
+   * @param ledgerId - Unique identifier for the ledger (e.g., 'hedera', 'xrpl')
+   * @returns The signer instance for the specified ledger
+   * @throws Error if no signer is registered for the ledger ID
+   */
+  static getSigner(ledgerId: string): IWalletConnectSigner {
+    const signer = this.signers.get(ledgerId);
+
+    if (!signer) {
+      const available = Array.from(this.signers.keys()).join(', ');
+      throw new Error(`Unsupported ledger: ${ledgerId}. Available ledgers: ${available}`);
+    }
+
+    return signer;
+  }
+
+  /**
+   * Register a custom signer for a ledger.
+   * Allows extending the factory with support for additional ledgers.
+   *
+   * @param ledgerId - Unique identifier for the ledger
+   * @param signer - Signer implementation for the ledger
+   */
+  static registerSigner(ledgerId: string, signer: IWalletConnectSigner): void {
+    if (signer.ledgerId !== ledgerId) {
+      logger.warn('Signer ledgerId does not match registration key', {
+        signerLedgerId: signer.ledgerId,
+        registrationKey: ledgerId,
+      });
+    }
+
+    this.signers.set(ledgerId, signer);
+    logger.debug('Registered signer for ledger', { ledgerId });
+  }
+
+  /**
+   * Check if a signer is registered for a ledger.
+   *
+   * @param ledgerId - Ledger identifier to check
+   * @returns True if a signer is registered, false otherwise
+   */
+  static hasSigner(ledgerId: string): boolean {
+    return this.signers.has(ledgerId);
+  }
+
+  /**
+   * Get all registered ledger IDs.
+   *
+   * @returns Array of ledger identifiers
+   */
+  static getAvailableLedgers(): string[] {
+    return Array.from(this.signers.keys());
+  }
+
+  /**
+   * Remove a signer from the registry.
+   * Useful for testing or dynamic ledger support.
+   *
+   * @param ledgerId - Ledger identifier to remove
+   * @returns True if signer was removed, false if it didn't exist
+   */
+  static unregisterSigner(ledgerId: string): boolean {
+    const removed = this.signers.delete(ledgerId);
+    if (removed) {
+      logger.debug('Unregistered signer for ledger', { ledgerId });
+    }
+    return removed;
+  }
+}

package/src/lib/providers/walletconnect/signers/xrpl-signer.spec.ts

@@ -0,0 +1,296 @@
+/**
+ * @file xrpl-signer.spec.ts
+ * @description Unit tests for XrplSigner
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { XrplSigner } from './xrpl-signer';
+import type { SignerOperationParams } from '../core/base-signer.interface';
+
+describe('XrplSigner', () => {
+  let signer: XrplSigner;
+  let mockClient: any;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [XrplSigner]
+    });
+    
+    signer = TestBed.inject(XrplSigner);
+    
+    mockClient = {
+      request: vi.fn()
+    };
+  });
+
+  describe('ledgerId', () => {
+    it('should be "xrpl"', () => {
+      expect(signer.ledgerId).toBe('xrpl');
+    });
+  });
+
+  describe('buildNamespace', () => {
+    it('should build correct namespace for testnet', () => {
+      const namespace = signer.buildNamespace('xrpl:testnet');
+      
+      expect(namespace.methods).toContain('xrpl_signTransaction');
+      expect(namespace.methods).toContain('xrpl_signAndSubmit');
+      expect(namespace.methods).toContain('xrpl_signMessage');
+      expect(namespace.chains).toEqual(['xrpl:testnet']);
+      expect(namespace.events).toContain('accountsChanged');
+    });
+
+    it('should build correct namespace for mainnet', () => {
+      const namespace = signer.buildNamespace('xrpl:mainnet');
+      
+      expect(namespace.chains).toEqual(['xrpl:mainnet']);
+    });
+  });
+
+  describe('signTransaction', () => {
+    let mockParams: SignerOperationParams;
+
+    beforeEach(() => {
+      const mockTransaction = {
+        TransactionType: 'Payment',
+        Account: 'rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE',
+        Destination: 'rLHzPsX6oXkzU9qL8qWDwgNfEwgR7pqxjy',
+        Amount: '1000000',
+        Fee: '12',
+        Sequence: 1
+      };
+      
+      const payload = btoa(JSON.stringify(mockTransaction));
+      
+      mockParams = {
+        client: mockClient,
+        topic: 'test-topic',
+        networkId: 'xrpl:testnet',
+        accountAddress: 'rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE',
+        payload
+      };
+      
+      vi.mocked(mockClient.request).mockResolvedValue({
+        tx_blob: 'signedTransactionBlob'
+      });
+    });
+
+    it('should call xrpl_signTransaction with correct params', async () => {
+      await signer.signTransaction(mockParams);
+      
+      expect(mockClient.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          topic: 'test-topic',
+          chainId: 'xrpl:testnet',
+          request: expect.objectContaining({
+            method: 'xrpl_signTransaction',
+            params: expect.objectContaining({
+              transaction: expect.any(Object)
+            })
+          })
+        })
+      );
+    });
+
+    it('should decode transaction from base64 JSON', async () => {
+      await signer.signTransaction(mockParams);
+      
+      const callArgs = vi.mocked(mockClient.request).mock.calls[0][0];
+      const transaction = callArgs.request.params.transaction;
+      
+      expect(transaction.TransactionType).toBe('Payment');
+      expect(transaction.Account).toBe('rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE');
+    });
+
+    it('should return signed payload', async () => {
+      const result = await signer.signTransaction(mockParams);
+      
+      expect(result).toEqual({
+        signedPayload: 'signedTransactionBlob',
+        metadata: expect.objectContaining({
+          result: expect.any(Object)
+        })
+      });
+    });
+
+    it('should throw error if request fails', async () => {
+      vi.mocked(mockClient.request).mockRejectedValue(new Error('User rejected'));
+      
+      await expect(signer.signTransaction(mockParams)).rejects.toThrow('XRPL sign failed');
+    });
+  });
+
+  describe('submitTransaction', () => {
+    let mockParams: SignerOperationParams;
+
+    beforeEach(() => {
+      const mockTransaction = {
+        TransactionType: 'Payment',
+        Account: 'rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE',
+        Destination: 'rLHzPsX6oXkzU9qL8qWDwgNfEwgR7pqxjy',
+        Amount: '1000000',
+        Fee: '12',
+        Sequence: 1
+      };
+      
+      const payload = btoa(JSON.stringify(mockTransaction));
+      
+      mockParams = {
+        client: mockClient,
+        topic: 'test-topic',
+        networkId: 'xrpl:testnet',
+        accountAddress: 'rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE',
+        payload
+      };
+      
+      vi.mocked(mockClient.request).mockResolvedValue({
+        hash: 'ABC123DEF456',
+        id: 'tx-id-123'
+      });
+    });
+
+    it('should call xrpl_signAndSubmit with correct params', async () => {
+      await signer.submitTransaction(mockParams);
+      
+      expect(mockClient.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          topic: 'test-topic',
+          chainId: 'xrpl:testnet',
+          request: expect.objectContaining({
+            method: 'xrpl_signAndSubmit',
+            params: expect.objectContaining({
+              transaction: expect.any(Object)
+            })
+          })
+        })
+      );
+    });
+
+    it('should return transaction ID and hash', async () => {
+      const result = await signer.submitTransaction(mockParams);
+      
+      expect(result).toEqual({
+        transactionId: 'ABC123DEF456',
+        transactionHash: 'ABC123DEF456',
+        metadata: expect.any(Object)
+      });
+    });
+
+    it('should return empty transactionId if hash missing', async () => {
+      // The implementation extracts transactionId from hash or tx_json.hash
+      // If both are missing, it returns empty string
+      vi.mocked(mockClient.request).mockResolvedValue({
+        id: 'tx-id-only' // id is not used for transactionId
+      });
+      
+      const result = await signer.submitTransaction(mockParams);
+      
+      // Returns empty string when hash fields are not present
+      expect(result.transactionId).toBe('');
+    });
+
+    it('should throw error if submission fails', async () => {
+      vi.mocked(mockClient.request).mockRejectedValue(new Error('Network error'));
+      
+      await expect(signer.submitTransaction(mockParams)).rejects.toThrow('XRPL submit failed');
+    });
+  });
+
+  describe('parseAccounts', () => {
+    it('should parse XRPL account format correctly', () => {
+      const namespace = {
+        accounts: [
+          'xrpl:testnet:rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE',
+          'xrpl:testnet:rLHzPsX6oXkzU9qL8qWDwgNfEwgR7pqxjy',
+          'xrpl:mainnet:rDsbeomae4FXwgQTJp9Rs64Qg9vDiTCdBv'
+        ]
+      };
+      
+      const accounts = signer.parseAccounts(namespace);
+      
+      expect(accounts).toHaveLength(3);
+      expect(accounts[0]).toEqual({
+        address: 'rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE',
+        chainId: 'xrpl:testnet'
+      });
+      expect(accounts[2]).toEqual({
+        address: 'rDsbeomae4FXwgQTJp9Rs64Qg9vDiTCdBv',
+        chainId: 'xrpl:mainnet'
+      });
+    });
+
+    it('should handle invalid account format gracefully', () => {
+      const namespace = {
+        accounts: ['invalid']
+      };
+      
+      const accounts = signer.parseAccounts(namespace);
+      
+      expect(accounts).toHaveLength(1);
+      expect(accounts[0]).toEqual({
+        address: 'invalid',
+        chainId: 'xrpl:testnet'
+      });
+    });
+
+    it('should handle empty accounts', () => {
+      const namespace = {
+        accounts: []
+      };
+      
+      const accounts = signer.parseAccounts(namespace);
+      
+      expect(accounts).toHaveLength(0);
+    });
+    
+    describe('network filtering', () => {
+      const mixedNetworkNamespace = {
+        accounts: [
+          'xrpl:testnet:rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE',
+          'xrpl:testnet:rLHzPsX6oXkzU9qL8qWDwgNfEwgR7pqxjy',
+          'xrpl:mainnet:rDsbeomae4FXwgQTJp9Rs64Qg9vDiTCdBv',
+          'xrpl:mainnet:rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
+          'xrpl:devnet:rBKz5MC2iXdoS3XgnNSYmF69K1Yo4NS3Ws'
+        ]
+      };
+      
+      it('should filter accounts by testnet when targetNetworkId is specified', () => {
+        const accounts = signer.parseAccounts(mixedNetworkNamespace, 'xrpl:testnet');
+        
+        expect(accounts).toHaveLength(2);
+        expect(accounts.every(acc => acc.chainId === 'xrpl:testnet')).toBe(true);
+      });
+      
+      it('should filter accounts by mainnet when targetNetworkId is specified', () => {
+        const accounts = signer.parseAccounts(mixedNetworkNamespace, 'xrpl:mainnet');
+        
+        expect(accounts).toHaveLength(2);
+        expect(accounts.every(acc => acc.chainId === 'xrpl:mainnet')).toBe(true);
+      });
+      
+      it('should filter accounts by devnet when targetNetworkId is specified', () => {
+        const accounts = signer.parseAccounts(mixedNetworkNamespace, 'xrpl:devnet');
+        
+        expect(accounts).toHaveLength(1);
+        expect(accounts[0].chainId).toBe('xrpl:devnet');
+      });
+      
+      it('should return empty array if no accounts match target network', () => {
+        const testnetOnlyNamespace = {
+          accounts: ['xrpl:testnet:rN7n7otQDd6FczFgLdlqtyMVrn3HMfeeZE']
+        };
+        
+        const accounts = signer.parseAccounts(testnetOnlyNamespace, 'xrpl:mainnet');
+        
+        expect(accounts).toHaveLength(0);
+      });
+      
+      it('should return all accounts when no targetNetworkId is provided', () => {
+        const accounts = signer.parseAccounts(mixedNetworkNamespace);
+        
+        expect(accounts).toHaveLength(5);
+      });
+    });
+  });
+});