@hsuite/native-connect-angular 1.0.0

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

@@ -0,0 +1,367 @@
+/**
+ * @file hedera-signer.spec.ts
+ * @description Unit tests for HederaSigner
+ *
+ * @compodoc
+ * These tests verify the WalletConnect signing functionality for Hedera.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { HederaSigner } from './hedera-signer';
+import { TransferTransaction, AccountId, Hbar, TransactionId } from '@hashgraph/sdk';
+import type { SignerOperationParams } from '../core/base-signer.interface';
+
+describe('HederaSigner', () => {
+  let signer: HederaSigner;
+  let mockClient: any;
+  let mockSession: any;
+
+  beforeEach(() => {
+    // HederaSigner doesn't need Angular DI - instantiate directly
+    signer = new HederaSigner();
+
+    // Mock WalletConnect client
+    mockClient = {
+      request: vi.fn(),
+      session: {
+        get: vi.fn(),
+      },
+    };
+
+    // Mock session
+    mockSession = {
+      topic: 'test-topic-123',
+      namespaces: {
+        hedera: {
+          accounts: ['hedera:testnet:0.0.12345', 'hedera:testnet:0.0.67890'],
+          methods: ['hedera_signTransaction', 'hedera_signAndExecuteTransaction'],
+          chains: ['hedera:testnet'],
+        },
+      },
+    };
+  });
+
+  describe('ledgerId', () => {
+    it('should be "hedera"', () => {
+      expect(signer.ledgerId).toBe('hedera');
+    });
+  });
+
+  describe('buildNamespace', () => {
+    it('should build correct namespace with all required methods', () => {
+      const namespace = signer.buildNamespace('hedera:testnet');
+
+      expect(namespace.methods).toContain('hedera_signTransaction');
+      expect(namespace.methods).toContain('hedera_signAndExecuteTransaction');
+      expect(namespace.methods).toContain('hedera_signMessage');
+      expect(namespace.events).toContain('accountsChanged');
+    });
+
+    it('should request ALL Hedera networks for wallet compatibility', () => {
+      // We request all networks to allow wallets like Kabila to show all accounts
+      // Account filtering by user-selected network happens in parseAccounts()
+      const namespace = signer.buildNamespace('hedera:testnet');
+
+      expect(namespace.chains).toContain('hedera:testnet');
+      expect(namespace.chains).toContain('hedera:mainnet');
+    });
+
+    it('should return same chains regardless of requested network', () => {
+      const testnetNamespace = signer.buildNamespace('hedera:testnet');
+      const mainnetNamespace = signer.buildNamespace('hedera:mainnet');
+
+      // All should return the same chains array
+      expect(testnetNamespace.chains).toEqual(mainnetNamespace.chains);
+    });
+  });
+
+  describe('signTransaction', () => {
+    // Create a valid frozen TransferTransaction for testing
+    let validTransactionBase64: string;
+
+    beforeEach(() => {
+      // Create a properly configured transaction
+      const transactionId = TransactionId.generate(AccountId.fromString('0.0.12345'));
+
+      const tx = new TransferTransaction()
+        .addHbarTransfer(AccountId.fromString('0.0.12345'), Hbar.fromTinybars(-100))
+        .addHbarTransfer(AccountId.fromString('0.0.12346'), Hbar.fromTinybars(100))
+        .setTransactionId(transactionId)
+        .setNodeAccountIds([AccountId.fromString('0.0.3')])
+        .freeze();
+
+      // Get the transaction bytes and encode to base64
+      const txBytes = tx.toBytes();
+      validTransactionBase64 = Buffer.from(txBytes).toString('base64');
+
+      // Reset mock for each test
+      mockClient.request.mockReset();
+    });
+
+    it('should call hedera_signTransaction with correct params', async () => {
+      mockClient.request.mockResolvedValue({
+        signatureMap: 'test-signature-map',
+      });
+
+      const mockParams = {
+        client: mockClient,
+        topic: 'test-topic',
+        networkId: 'hedera:testnet',
+        accountAddress: '0.0.12345',
+        payload: validTransactionBase64,
+      };
+
+      await signer.signTransaction(mockParams);
+
+      expect(mockClient.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          topic: 'test-topic',
+          chainId: 'hedera:testnet',
+          request: expect.objectContaining({
+            method: 'hedera_signTransaction',
+            params: expect.objectContaining({
+              signerAccountId: 'hedera:testnet:0.0.12345',
+              // Now sends transactionList (full frozen bytes) instead of transactionBody
+              // This preserves canonical bytes for correct signature verification
+              transactionList: validTransactionBase64,
+            }),
+          }),
+        }),
+      );
+    });
+
+    it('should return signed payload from response', async () => {
+      mockClient.request.mockResolvedValue({
+        signatureMap: 'returned-signature-map',
+      });
+
+      const mockParams = {
+        client: mockClient,
+        topic: 'test-topic',
+        networkId: 'hedera:testnet',
+        accountAddress: '0.0.12345',
+        payload: validTransactionBase64,
+      };
+
+      const result = await signer.signTransaction(mockParams);
+
+      expect(result.signedPayload).toBe('returned-signature-map');
+      expect(result.metadata).toBeDefined();
+    });
+
+    it('should handle mainnet network ID', async () => {
+      mockClient.request.mockResolvedValue({
+        signatureMap: 'mainnet-signature',
+      });
+
+      const mockParams = {
+        client: mockClient,
+        topic: 'test-topic',
+        networkId: 'hedera:mainnet',
+        accountAddress: '0.0.12345',
+        payload: validTransactionBase64,
+      };
+
+      await signer.signTransaction(mockParams);
+
+      expect(mockClient.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          chainId: 'hedera:mainnet',
+          request: expect.objectContaining({
+            params: expect.objectContaining({
+              signerAccountId: 'hedera:mainnet:0.0.12345',
+            }),
+          }),
+        }),
+      );
+    });
+
+    it('should throw error if request fails', async () => {
+      const mockPayload = Buffer.from('invalid-bytes').toString('base64');
+      const mockParams = {
+        client: mockClient,
+        topic: 'test-topic',
+        networkId: 'hedera:testnet',
+        accountAddress: '0.0.12345',
+        payload: mockPayload,
+      };
+
+      // This will throw because the bytes are invalid
+      await expect(signer.signTransaction(mockParams)).rejects.toThrow('Hedera sign failed');
+    });
+  });
+
+  describe('submitTransaction', () => {
+    let mockParams: SignerOperationParams;
+
+    beforeEach(() => {
+      // Create a base64 encoded transaction payload
+      const mockPayload = Buffer.from('mock-transaction-bytes').toString('base64');
+
+      mockParams = {
+        client: mockClient,
+        topic: 'test-topic',
+        networkId: 'hedera:testnet',
+        accountAddress: '0.0.12345',
+        payload: mockPayload,
+      };
+
+      mockClient.request.mockResolvedValue({
+        transactionId: '0.0.12345@1699999999.123456789',
+      });
+    });
+
+    it('should call hedera_signAndExecuteTransaction with correct params', async () => {
+      await signer.submitTransaction(mockParams);
+
+      expect(mockClient.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          topic: 'test-topic',
+          chainId: 'hedera:testnet',
+          request: expect.objectContaining({
+            method: 'hedera_signAndExecuteTransaction',
+            params: expect.objectContaining({
+              signerAccountId: 'hedera:testnet:0.0.12345',
+              transactionList: mockParams.payload, // TransactionList format
+            }),
+          }),
+        }),
+      );
+    });
+
+    it('should use TransactionList format (frozen bytes)', async () => {
+      await signer.submitTransaction(mockParams);
+
+      const callArgs = mockClient.request.mock.calls[0][0];
+      const transactionList = callArgs.request.params.transactionList;
+
+      // Should be the same as the original payload (TransactionList)
+      expect(transactionList).toBe(mockParams.payload);
+    });
+
+    it('should return transaction ID', async () => {
+      const result = await signer.submitTransaction(mockParams);
+
+      expect(result).toEqual({
+        transactionId: '0.0.12345@1699999999.123456789',
+        transactionHash: undefined,
+        metadata: expect.any(Object),
+      });
+    });
+
+    it('should throw error if submission fails', async () => {
+      mockClient.request.mockRejectedValue(new Error('Network error'));
+
+      await expect(signer.submitTransaction(mockParams)).rejects.toThrow('Hedera submit failed');
+    });
+  });
+
+  describe('parseAccounts', () => {
+    it('should parse HIP-30 account format correctly', () => {
+      const namespace = {
+        accounts: [
+          'hedera:testnet:0.0.12345',
+          'hedera:testnet:0.0.67890',
+          'hedera:mainnet:0.0.99999',
+        ],
+      };
+
+      const accounts = signer.parseAccounts(namespace);
+
+      expect(accounts).toHaveLength(3);
+      expect(accounts[0]).toEqual({
+        address: '0.0.12345',
+        chainId: 'hedera:testnet',
+      });
+      expect(accounts[1]).toEqual({
+        address: '0.0.67890',
+        chainId: 'hedera:testnet',
+      });
+      expect(accounts[2]).toEqual({
+        address: '0.0.99999',
+        chainId: 'hedera:mainnet',
+      });
+    });
+
+    it('should handle invalid account format gracefully', () => {
+      const namespace = {
+        accounts: ['invalid-format'],
+      };
+
+      const accounts = signer.parseAccounts(namespace);
+
+      expect(accounts).toHaveLength(1);
+      expect(accounts[0]).toEqual({
+        address: 'invalid-format',
+        chainId: 'hedera:testnet', // Default fallback
+      });
+    });
+
+    it('should handle empty accounts array', () => {
+      const namespace = {
+        accounts: [],
+      };
+
+      const accounts = signer.parseAccounts(namespace);
+
+      expect(accounts).toHaveLength(0);
+    });
+
+    it('should handle missing accounts', () => {
+      const namespace = {};
+
+      const accounts = signer.parseAccounts(namespace);
+
+      expect(accounts).toHaveLength(0);
+    });
+
+    describe('network filtering', () => {
+      const mixedNetworkNamespace = {
+        accounts: [
+          'hedera:testnet:0.0.12345',
+          'hedera:testnet:0.0.67890',
+          'hedera:mainnet:0.0.99999',
+          'hedera:mainnet:0.0.11111',
+        ],
+      };
+
+      it('should filter accounts by testnet when targetNetworkId is specified', () => {
+        const accounts = signer.parseAccounts(mixedNetworkNamespace, 'hedera:testnet');
+
+        expect(accounts).toHaveLength(2);
+        expect(accounts.every((acc) => acc.chainId === 'hedera:testnet')).toBe(true);
+        expect(accounts.map((acc) => acc.address)).toEqual(['0.0.12345', '0.0.67890']);
+      });
+
+      it('should filter accounts by mainnet when targetNetworkId is specified', () => {
+        const accounts = signer.parseAccounts(mixedNetworkNamespace, 'hedera:mainnet');
+
+        expect(accounts).toHaveLength(2);
+        expect(accounts.every((acc) => acc.chainId === 'hedera:mainnet')).toBe(true);
+        expect(accounts.map((acc) => acc.address)).toEqual(['0.0.99999', '0.0.11111']);
+      });
+
+      it('should return empty array if no accounts match target network', () => {
+        const testnetOnlyNamespace = {
+          accounts: ['hedera:testnet:0.0.12345'],
+        };
+
+        const accounts = signer.parseAccounts(testnetOnlyNamespace, 'hedera:mainnet');
+
+        expect(accounts).toHaveLength(0);
+      });
+
+      it('should return all accounts when no targetNetworkId is provided', () => {
+        const accounts = signer.parseAccounts(mixedNetworkNamespace);
+
+        expect(accounts).toHaveLength(4);
+      });
+
+      it('should return all accounts when targetNetworkId is undefined', () => {
+        const accounts = signer.parseAccounts(mixedNetworkNamespace, undefined);
+
+        expect(accounts).toHaveLength(4);
+      });
+    });
+  });
+});