@hsuite/native-connect-angular 1.0.0

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

@@ -0,0 +1,610 @@
+/**
+ * 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 hedera-signer.ts
+ * @description Hedera-specific WalletConnect signer implementation
+ *
+ * Implements the IWalletConnectSigner interface for Hedera ledger.
+ * Handles Hedera-specific JSON-RPC methods and transaction formats.
+ */
+
+import { getLogger } from '@hsuite/native-connect-sdk';
+
+import type { SignResult, SubmitResult } from '../../base-wallet-provider';
+import type { IWalletConnectSigner, SignerOperationParams } from '../core/base-signer.interface';
+
+const logger = getLogger().scoped?.('HederaSigner') ?? getLogger();
+
+/**
+ * Extract a meaningful error message from various error shapes.
+ * WalletConnect SDK throws errors that are not standard Error instances.
+ *
+ * Handles:
+ * - Standard Error objects
+ * - WalletConnect SDK errors: { code, message }
+ * - Nested errors: { error: { message } }
+ * - PIN_REQUIRED errors from wallet
+ * - DOMException objects
+ * - Objects that stringify to {} (enumerable property check)
+ *
+ * @param error - Error from WalletConnect SDK (can be Error, object, or string)
+ * @returns Human-readable error message
+ */
+function extractErrorMessage(error: unknown): string {
+  // Log the raw error for debugging
+  logger.debug('Extracting error message', {
+    errorType: typeof error,
+    isError: error instanceof Error,
+    constructorName: error?.constructor?.name,
+    protoName: Object.getPrototypeOf(error)?.constructor?.name,
+  });
+
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  if (typeof error === 'object' && error !== null) {
+    const errorObj = error as Record<string, unknown>;
+
+    // Try to get all properties including non-enumerable and from prototype
+    const allProps = Object.getOwnPropertyNames(error).concat(
+      Object.getOwnPropertyNames(Object.getPrototypeOf(error) || {}),
+    );
+
+    // Log ALL property values for debugging
+    const propDebug: Record<string, string> = {};
+    for (const prop of allProps.slice(0, 15)) {
+      try {
+        const val = (error as any)[prop];
+        if (typeof val === 'function') {
+          propDebug[prop] = '[fn]';
+        } else if (val === undefined) {
+          propDebug[prop] = 'undef';
+        } else if (val === null) {
+          propDebug[prop] = 'null';
+        } else if (typeof val === 'object') {
+          propDebug[prop] = JSON.stringify(val)?.substring(0, 60) || '[obj]';
+        } else {
+          propDebug[prop] = String(val).substring(0, 60);
+        }
+      } catch (_e) {
+        propDebug[prop] = '[err]';
+      }
+    }
+    logger.error('WC Error object dump', propDebug);
+
+    // Check for code property first (common in SDK errors like PIN_REQUIRED)
+    if (typeof errorObj['code'] === 'string') {
+      const codeMsg = errorObj['message']
+        ? `${errorObj['code']}: ${errorObj['message']}`
+        : errorObj['code'];
+      return codeMsg as string;
+    }
+
+    // WalletConnect error format: { code, message }
+    if ('message' in errorObj && typeof errorObj['message'] === 'string') {
+      return errorObj['message'];
+    }
+
+    // Nested error: { error: { message } }
+    if (
+      'error' in errorObj &&
+      typeof errorObj['error'] === 'object' &&
+      errorObj['error'] !== null
+    ) {
+      const nested = errorObj['error'] as Record<string, unknown>;
+      if ('message' in nested && typeof nested['message'] === 'string') {
+        return nested['message'];
+      }
+      if ('code' in nested && typeof nested['code'] === 'string') {
+        return nested['code'];
+      }
+    }
+
+    // Check for DOMException
+    if (error instanceof DOMException) {
+      return error.message || error.name;
+    }
+
+    // Check for reason/cause properties (common in rejected promises)
+    if ('reason' in errorObj && typeof errorObj['reason'] === 'string') {
+      return errorObj['reason'];
+    }
+    if ('cause' in errorObj) {
+      const cause = errorObj['cause'];
+      if (typeof cause === 'string') return cause;
+      if (cause instanceof Error) return cause.message;
+      if (typeof cause === 'object' && cause !== null && 'message' in (cause as any)) {
+        return String((cause as any).message);
+      }
+    }
+
+    // WalletConnect SDK specific error formats
+    if ('context' in errorObj && typeof errorObj['context'] === 'string') {
+      return errorObj['context'];
+    }
+    if ('data' in errorObj && typeof errorObj['data'] === 'object' && errorObj['data'] !== null) {
+      const data = errorObj['data'] as Record<string, unknown>;
+      if ('message' in data && typeof data['message'] === 'string') {
+        return data['message'];
+      }
+    }
+
+    // WalletConnect JSON-RPC error format: { code: number, message: string }
+    if ('code' in errorObj && 'message' in errorObj) {
+      const code = errorObj['code'];
+      const msg = errorObj['message'];
+      if (typeof msg === 'string') {
+        return typeof code === 'number' ? `[${code}] ${msg}` : msg;
+      }
+    }
+
+    // Error with 'name' property (common for built-in errors)
+    if ('name' in errorObj && typeof errorObj['name'] === 'string') {
+      const name = errorObj['name'];
+      if (name && name !== 'Error' && name !== 'Object') {
+        return name;
+      }
+    }
+
+    // Try to stringify, but check if result is empty object
+    try {
+      const jsonStr = JSON.stringify(error);
+      // Don't return empty objects as error messages
+      if (jsonStr && jsonStr !== '{}' && jsonStr !== '[]') {
+        return jsonStr;
+      }
+
+      // If stringify returned {}, try Object.keys to get property names
+      const keys = Object.keys(errorObj);
+      if (keys.length > 0) {
+        return `Error object with keys: ${keys.join(', ')}`;
+      }
+
+      // Try getting own property names (includes non-enumerable)
+      const ownProps = Object.getOwnPropertyNames(errorObj);
+      logger.debug('Error object properties', { props: ownProps });
+
+      if (ownProps.length > 0) {
+        // Try to read ALL properties for better debugging
+        const propValues: string[] = [];
+        for (const k of ownProps) {
+          try {
+            const val = errorObj[k];
+            const valStr = typeof val === 'object' ? JSON.stringify(val) : String(val);
+            propValues.push(`${k}=${valStr?.substring(0, 100)}`);
+
+            // Check if any property contains error info
+            if (typeof val === 'object' && val !== null) {
+              if ('message' in val) return String((val as any).message);
+              if ('error' in val) return String((val as any).error);
+            }
+          } catch {
+            propValues.push(k);
+          }
+        }
+        logger.debug('Error property values', { values: propValues });
+
+        // Return a more informative error
+        return `Error with properties: ${propValues.slice(0, 5).join(', ')}`;
+      }
+    } catch (_e) {
+      // If stringify fails, try toString
+      const str = String(error);
+      if (str !== '[object Object]') {
+        return str;
+      }
+    }
+
+    // Last resort - log what we know about the object
+    logger.warn('Could not extract error message', {
+      constructor: error?.constructor?.name,
+      prototype: Object.getPrototypeOf(error)?.constructor?.name,
+    });
+    return `Unknown error (type: ${error?.constructor?.name || 'object'})`;
+  }
+
+  if (typeof error === 'string') {
+    return error;
+  }
+
+  return 'Unknown error';
+}
+
+/**
+ * Signer implementation for Hedera ledger.
+ *
+ * Supports Hedera-specific WalletConnect methods:
+ * - hedera_signTransaction (sign-only, returns signature map)
+ * - hedera_signAndExecuteTransaction (sign + submit, returns transaction ID)
+ * - hedera_executeTransaction
+ * - hedera_signMessage (arbitrary message signing)
+ *
+ * Uses HIP-30 account format: hedera:<network>:<accountId>
+ */
+export class HederaSigner implements IWalletConnectSigner {
+  readonly ledgerId = 'hedera';
+
+  /**
+   * Build Hedera namespace configuration for WalletConnect.
+   * Defines the JSON-RPC methods and chains this signer supports.
+   *
+   * IMPORTANT: We request ALL Hedera networks (testnet, mainnet)
+   * to ensure wallets like Kabila can show accounts from unknown network.
+   * The wallet will return all accounts it has across all networks.
+   *
+   * @param networkId - Network identifier (e.g., 'hedera:testnet', 'hedera:mainnet')
+   * @param _networkId
+   * @returns Namespace configuration object
+   */
+  buildNamespace(_networkId: string): {
+    methods: string[];
+    chains: string[];
+    events: string[];
+  } {
+    // Request ALL Hedera networks to allow wallets to show all their accounts
+    // Wallets like Kabila may have accounts on multiple networks
+
+    return {
+      methods: [
+        'hedera_signTransaction',
+        'hedera_signAndExecuteTransaction',
+        'hedera_executeTransaction',
+        'hedera_signMessage',
+      ],
+      // Request all Hedera networks so wallet can show all accounts
+      chains: ['hedera:testnet', 'hedera:mainnet'],
+      events: ['chainChanged', 'accountsChanged'],
+    };
+  }
+
+  /**
+   * Sign a Hedera transaction without submitting to network.
+   * Uses hedera_signTransaction method with TransactionList format.
+   *
+   * The payload comes as TransactionList (base64 frozen transaction bytes).
+   * We send the full TransactionList to preserve canonical bytes for signing.
+   * The wallet will sign and return the signature map without executing.
+   *
+   * @param params - Signing parameters (payload is TransactionList base64)
+   * @returns Promise resolving to signed transaction with signature map
+   */
+  async signTransaction(params: SignerOperationParams): Promise<SignResult> {
+    // Extract network name from networkId (mainnet or testnet)
+    const network = params.networkId.includes('mainnet') ? 'mainnet' : 'testnet';
+
+    // Format account ID in HIP-30 format
+    const signerAccountId = `hedera:${network}:${params.accountAddress}`;
+
+    try {
+      // Send the full TransactionList (frozen transaction bytes) to preserve canonical bytes.
+      // The wallet needs the complete transaction structure to sign correctly.
+      // Previously we converted to TransactionBody which caused INVALID_SIGNATURE errors
+      // because the signature was computed over different bytes than the network expected.
+
+      // Use 5-minute expiry to give users time to review and approve
+      const result = await params.client.request({
+        topic: params.topic,
+        chainId: `hedera:${network}`,
+        request: {
+          method: 'hedera_signTransaction',
+          params: {
+            signerAccountId,
+            transactionList: params.payload, // Send full TransactionList for correct signing
+          },
+        },
+        expiry: 300, // 5 minutes in seconds
+      });
+
+      return {
+        signedPayload: String(
+          (result as { signatureMap?: any }).signatureMap ||
+            (result as { signedTransaction?: any }).signedTransaction ||
+            JSON.stringify(result),
+        ),
+        metadata: { result },
+      };
+    } catch (error) {
+      // Check if this is an empty error object (WalletConnect SDK bug)
+      const isEmptyError =
+        typeof error === 'object' &&
+        error !== null &&
+        Object.keys(error).length === 0 &&
+        !(error instanceof Error);
+
+      if (isEmptyError) {
+        logger.warn('WalletConnect SDK empty error - relay subscription may have been stale', {
+          topic: params.topic?.substring(0, 16) + '...',
+        });
+        throw new Error('WalletConnect connection issue - please try again');
+      }
+
+      const errorMsg = extractErrorMessage(error);
+      logger.error('Sign failed', { error: errorMsg });
+      throw new Error(`Hedera sign failed: ${errorMsg}`);
+    }
+  }
+
+  /**
+   * Sign and submit a Hedera transaction to the network.
+   * Uses hedera_signAndExecuteTransaction method with TransactionList format.
+   *
+   * @param params - Submission parameters
+   * @returns Promise resolving to transaction ID and metadata
+   */
+  async submitTransaction(params: SignerOperationParams): Promise<SubmitResult> {
+    // Extract network name from networkId (mainnet or testnet)
+    const network = params.networkId.includes('mainnet') ? 'mainnet' : 'testnet';
+
+    // Format account ID in HIP-30 format
+    const signerAccountId = `hedera:${network}:${params.accountAddress}`;
+
+    logger.debug('Sending hedera_signAndExecuteTransaction request', {
+      topic: params.topic?.substring(0, 16) + '...',
+      chainId: `hedera:${network}`,
+      signerAccountId,
+      payloadLength: params.payload?.length,
+    });
+
+    // Create the request promise - keep-alive pings are handled by WalletConnectClientManager
+    const requestPromise = params.client.request({
+      topic: params.topic,
+      chainId: `hedera:${network}`,
+      request: {
+        method: 'hedera_signAndExecuteTransaction',
+        params: {
+          signerAccountId,
+          transactionList: params.payload, // TransactionList protobuf (base64)
+        },
+      },
+      expiry: 300, // 5 minutes in seconds
+    });
+
+    // Create a 5-minute timeout to override any internal SDK timeouts
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(
+        () => {
+          reject(new Error('Transaction approval timed out after 5 minutes'));
+        },
+        5 * 60 * 1000,
+      ); // 5 minutes
+    });
+
+    try {
+      // Race between the request and our timeout
+      const result = await Promise.race([requestPromise, timeoutPromise]);
+
+      logger.debug('Received hedera_signAndExecuteTransaction response', {
+        hasResult: !!result,
+        resultKeys: result ? Object.keys(result as object) : [],
+      });
+
+      return {
+        transactionId:
+          (result as { transactionId?: string }).transactionId ||
+          (result as { response?: { transactionId?: string } }).response?.transactionId ||
+          '',
+        transactionHash: (result as { transactionHash?: string }).transactionHash,
+        metadata: { result },
+      };
+    } catch (error) {
+      // Log full error for debugging - try to get more info from WalletConnect error
+      const wcError = error as any;
+
+      // Try to extract all available error info
+      const errorInfo = {
+        errorType: typeof error,
+        errorConstructor: error?.constructor?.name,
+        errorKeys: error && typeof error === 'object' ? Object.keys(error) : [],
+        errorString: String(error),
+        // WalletConnect specific error properties
+        wcCode: wcError?.code,
+        wcMessage: wcError?.message,
+        wcContext: wcError?.context,
+        wcData: wcError?.data,
+        // Try Symbol properties
+        symbols:
+          error && typeof error === 'object'
+            ? Object.getOwnPropertySymbols(error).map((s) => s.toString())
+            : [],
+        // Get all own property names
+        ownProps: error && typeof error === 'object' ? Object.getOwnPropertyNames(error) : [],
+      };
+
+      logger.error('Submit failed - full error analysis', errorInfo);
+
+      // Check if this is an empty error object (WalletConnect SDK bug)
+      // This typically happens when relay subscription is stale
+      const isEmptyError =
+        typeof error === 'object' &&
+        error !== null &&
+        Object.keys(error).length === 0 &&
+        !(error instanceof Error);
+
+      if (isEmptyError) {
+        // Empty error object is a known WalletConnect SDK issue
+        // It usually means the relay subscription was stale
+        // The SessionHealthManager should have pinged before the request,
+        // but if we still get this error, the subscription dropped after the ping
+        logger.warn('WalletConnect SDK empty error - relay subscription may have been stale', {
+          topic: params.topic?.substring(0, 16) + '...',
+          hint: 'This can happen when the relay WebSocket connection drops',
+        });
+        // NOTE: We can't retry because the wallet may have already executed the transaction.
+        // A retry could cause a duplicate transaction on Hedera.
+        throw new Error(
+          'WalletConnect connection dropped - if you approved the transaction in your wallet, ' +
+            'please check your transaction history as it may have been executed successfully.',
+        );
+      }
+
+      const errorMsg = extractErrorMessage(error);
+      logger.error('Submit failed', { error: errorMsg });
+      throw new Error(`Hedera submit failed: ${errorMsg}`);
+    }
+  }
+
+  /**
+   * Sign and execute a transaction in one call (alias for submitTransaction).
+   * Uses hedera_signAndExecuteTransaction WalletConnect RPC method.
+   * This prevents double prompts by using the native WalletConnect method.
+   *
+   * @param params - Transaction parameters
+   * @returns Promise resolving to transaction ID and metadata
+   */
+  async signAndExecuteTransaction(params: SignerOperationParams): Promise<SubmitResult> {
+    // Simply delegate to submitTransaction which already uses hedera_signAndExecuteTransaction
+    return this.submitTransaction(params);
+  }
+
+  /**
+   * Sign an arbitrary message using hedera_signMessage method.
+   * Used for DAO votes, authentication proofs, and other non-transaction signing.
+   *
+   * @param params - Signing parameters with message string
+   * @returns Promise resolving to signature and metadata
+   */
+  async signMessage(
+    params: SignerOperationParams & { message: string; encoding?: 'utf-8' | 'base64' },
+  ): Promise<import('../../base-wallet-provider').SignMessageResult> {
+    // Extract network name from networkId (mainnet or testnet)
+    const network = params.networkId.includes('mainnet') ? 'mainnet' : 'testnet';
+
+    // Format account ID in HIP-30 format
+    const signerAccountId = `hedera:${network}:${params.accountAddress}`;
+
+    try {
+      // Use 5-minute expiry to give users time to review and approve
+      const result = await params.client.request({
+        topic: params.topic,
+        chainId: `hedera:${network}`,
+        request: {
+          method: 'hedera_signMessage',
+          params: {
+            signerAccountId,
+            message: params.message, // Can be base64 or utf-8
+          },
+        },
+        expiry: 300, // 5 minutes in seconds
+      });
+
+      return {
+        signature: String(
+          (result as { signatureMap?: any }).signatureMap ||
+            (result as { signature?: any }).signature ||
+            JSON.stringify(result),
+        ),
+        publicKey: (result as { publicKey?: string }).publicKey,
+        metadata: { result },
+      };
+    } catch (error) {
+      // Check if this is an empty error object (WalletConnect SDK bug)
+      const isEmptyError =
+        typeof error === 'object' &&
+        error !== null &&
+        Object.keys(error).length === 0 &&
+        !(error instanceof Error);
+
+      if (isEmptyError) {
+        logger.warn('WalletConnect SDK empty error - relay subscription may have been stale', {
+          topic: params.topic?.substring(0, 16) + '...',
+        });
+        throw new Error('WalletConnect connection issue - please try again');
+      }
+
+      const errorMsg = extractErrorMessage(error);
+      logger.error('Sign message failed', { error: errorMsg });
+      throw new Error(`Hedera sign message failed: ${errorMsg}`);
+    }
+  }
+
+  /**
+   * Parse accounts from Hedera namespace in WalletConnect session.
+   * Extracts account IDs from HIP-30 format: hedera:<network>:<accountId>
+   *
+   * Optionally filters accounts to only include those matching a target network.
+   * This is important for respecting the user's network selection in the dApp,
+   * since wallets may return accounts from multiple networks.
+   *
+   * @param namespace - Hedera namespace object from session
+   * @param targetNetworkId - Optional network ID to filter accounts (e.g., 'hedera:mainnet')
+   * @returns Array of parsed account objects, filtered by target network if specified
+   */
+  parseAccounts(
+    namespace: any,
+    targetNetworkId?: string,
+  ): Array<{ address: string; chainId: string }> {
+    if (!namespace) {
+      logger.warn('Namespace is null or undefined');
+      return [];
+    }
+
+    if (!(namespace as { accounts?: string[] }).accounts) {
+      logger.warn('Namespace has no accounts property');
+      return [];
+    }
+
+    if (!Array.isArray((namespace as { accounts?: string[] }).accounts)) {
+      logger.warn('Namespace accounts is not an array', {
+        type: typeof (namespace as { accounts?: string[] }).accounts,
+      });
+      return [];
+    }
+
+    // Parse all accounts from namespace
+    const allAccounts = ((namespace as { accounts?: string[] }).accounts || []).map(
+      (account: string) => {
+        // HIP-30 format: hedera:testnet:0.0.12345
+        const parts = account.split(':');
+
+        if (parts.length < 3) {
+          logger.warn('Invalid account format', { account, partsLength: parts.length });
+          return { address: account, chainId: 'hedera:testnet' };
+        }
+
+        return {
+          address: parts[parts.length - 1], // Account ID (0.0.12345)
+          chainId: `${parts[0]}:${parts[1]}`, // hedera:testnet
+        };
+      },
+    );
+
+    // If target network specified, filter accounts to only that network
+    if (targetNetworkId) {
+      const targetNetwork = targetNetworkId.split(':')[1]?.toLowerCase(); // e.g., 'mainnet'
+
+      if (targetNetwork) {
+        const filteredAccounts = allAccounts.filter((acc) =>
+          acc.chainId.toLowerCase().includes(targetNetwork),
+        );
+
+        logger.debug('Filtered accounts by target network', {
+          targetNetworkId,
+          targetNetwork,
+          totalAccounts: allAccounts.length,
+          filteredCount: filteredAccounts.length,
+        });
+
+        // If no accounts match the target network, log a warning
+        if (filteredAccounts.length === 0 && allAccounts.length > 0) {
+          logger.warn('No accounts found for target network', {
+            targetNetwork,
+            availableNetworks: [...new Set(allAccounts.map((a) => a.chainId))],
+          });
+        }
+
+        return filteredAccounts;
+      }
+    }
+
+    return allAccounts;
+  }
+}

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

@@ -0,0 +1,62 @@
+/**
+ * @file signer-factory.spec.ts
+ * @description Unit tests for SignerFactory
+ * 
+ * @compodoc
+ * SignerFactory uses static methods for signer management,
+ * so tests call static methods directly rather than using DI.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SignerFactory } from './signer-factory';
+
+describe('SignerFactory', () => {
+  describe('getSigner', () => {
+    it('should return a signer for "hedera" ledger ID', () => {
+      const signer = SignerFactory.getSigner('hedera');
+      
+      expect(signer).toBeDefined();
+      expect(signer.ledgerId).toBe('hedera');
+    });
+
+    it('should return a signer for "xrpl" ledger ID', () => {
+      const signer = SignerFactory.getSigner('xrpl');
+      
+      expect(signer).toBeDefined();
+      expect(signer.ledgerId).toBe('xrpl');
+    });
+
+    it('should throw error for unknown ledger ID', () => {
+      expect(() => {
+        SignerFactory.getSigner('unknown');
+      }).toThrow('Unsupported ledger: unknown');
+    });
+
+    it('should return same instance on multiple calls (singleton)', () => {
+      const signer1 = SignerFactory.getSigner('hedera');
+      const signer2 = SignerFactory.getSigner('hedera');
+      
+      expect(signer1).toBe(signer2);
+    });
+  });
+
+  describe('hasSigner', () => {
+    it('should return true for registered ledger', () => {
+      expect(SignerFactory.hasSigner('hedera')).toBe(true);
+      expect(SignerFactory.hasSigner('xrpl')).toBe(true);
+    });
+
+    it('should return false for unregistered ledger', () => {
+      expect(SignerFactory.hasSigner('solana')).toBe(false);
+    });
+  });
+
+  describe('getAvailableLedgers', () => {
+    it('should return list of available ledgers', () => {
+      const ledgers = SignerFactory.getAvailableLedgers();
+      
+      expect(ledgers).toContain('hedera');
+      expect(ledgers).toContain('xrpl');
+    });
+  });
+});