chore: 1. 为硬件钱包添加 WalletConnect 链接功能。2. 支持两种签名方式。 3. 新增多语种配置 USB

Author: Yuejian

packages/common/src/locale/en_US.ts

@@ -42,6 +42,7 @@ const localeValues: RequiredLocale = {
     guideTipTitle: 'New to crypto wallets?',
     guideTipLearnMoreLinkText: 'Learn More',
     walletPanelPlugin: 'PLUGIN',
+    walletPanelPluginHardware: 'USB',
     walletListEmpty: 'No wallet available',
     walletConnectSuccess: 'Wallet Connected!',
     getWalletTipsTitle: "Not what you're looking for?",

packages/common/src/locale/zh_HK.ts

@@ -40,6 +40,7 @@ const localeValues: RequiredLocale = {
     guideTipTitle: '第一次使用加密錢包？',
     guideTipLearnMoreLinkText: '了解更多',
     walletPanelPlugin: '插件',
+    walletPanelPluginHardware: 'USB',
     walletListEmpty: '未發現任何錢包',
     walletConnectSuccess: '錢包已連接！',
     getWalletTipsTitle: '沒有找到你想要的？',

packages/common/src/types.ts

@@ -307,6 +307,7 @@ export interface RequiredLocale {
     guideTipTitle: string;
     guideTipLearnMoreLinkText: string;
     walletPanelPlugin: string;
+    walletPanelPluginHardware: string;
     walletConnectSuccess: string;
     walletListEmpty: string;
     getWalletTipsTitle: string;

packages/ledger/package.json

@@ -48,6 +48,7 @@
     "@ledgerhq/device-management-kit": "^0.9.1",
     "@ledgerhq/device-signer-kit-ethereum": "^1.8.0",
     "@ledgerhq/device-transport-kit-web-hid": "^1.2.0",
+    "@walletconnect/universal-provider": "^2.14.0",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {

packages/ledger/src/ledger/errors.ts

@@ -8,7 +8,14 @@ export type LedgerErrorCode =
   | 'CANNOT_GET_ADDRESS'
   | 'NO_SESSION'
   | 'SIGN_MESSAGE_FAILED'
-  | 'SIGN_TYPED_DATA_FAILED';
+  | 'SIGN_TYPED_DATA_FAILED'
+  | 'WALLETCONNECT_NOT_CONFIGURED'
+  | 'WALLETCONNECT_PROVIDER_NOT_AVAILABLE'
+  | 'WALLETCONNECT_SESSION_NOT_AVAILABLE'
+  | 'WALLETCONNECT_NO_ACCOUNTS'
+  | 'WALLETCONNECT_INVALID_ACCOUNT'
+  | 'WALLETCONNECT_CONNECTION_FAILED'
+  | 'WALLETCONNECT_SESSION_TIMEOUT';
 
 /**
  * Extended Error class with code and details

packages/ledger/src/ledger/index.tsx

@@ -1,9 +1,9 @@
-import { Wallet } from '@ant-design/web3-common';
+import type { Account, Wallet } from '@ant-design/web3-common';
 import { LedgerFilled } from '@ant-design/web3-icons';
 import type { DeviceSessionId } from '@ledgerhq/device-management-kit';
 import { DeviceStatus as DeviceStatusType } from '@ledgerhq/device-management-kit';
 
-import { LedgerAccount } from '../types';
+import type { LedgerAccount } from '../types';
 import AppCommand from './AppCommand';
 import AvailableDevices from './AvailableDevices';
 import Connect from './Connect';
@@ -17,6 +17,12 @@ export class Ledger {
     icon: <LedgerFilled />,
     group: 'Hardware',
     remark: 'Ledger Hardware Wallet',
+    app: {
+      link: 'https://www.ledger.com/',
+    },
+    universalProtocol: {
+      link: 'https://www.ledger.com/',
+    },
     hasWalletReady: async () => true,
   };
 
@@ -31,6 +37,10 @@ export class Ledger {
   public sessionId: DeviceSessionId | null = null;
   public accounts: LedgerAccount[] = [];
 
+  private _getWalletConnectProvider?: () => Promise<any>;
+  private _walletConnectAccount?: Account;
+  private _sessionDeleteHandler?: () => void;
+
   constructor(name?: string, derivationPath?: string) {
     this.wallet.name = name || 'Ledger';
     this.derivationPath = derivationPath || "44'/60'/0'/0/0";
@@ -132,6 +142,12 @@ export class Ledger {
   };
 
   public signMessage = async (message: string) => {
+    // Check if using WalletConnect
+    if (this._walletConnectAccount) {
+      return this._signMessageWithWalletConnect(message);
+    }
+
+    // Use hardware wallet signing
     if (!this.sessionId) {
       throw new LedgerError(
         'NO_SESSION',
@@ -146,6 +162,12 @@ export class Ledger {
   };
 
   public signTypedData = async (typedData: any) => {
+    // Check if using WalletConnect
+    if (this._walletConnectAccount) {
+      return this._signTypedDataWithWalletConnect(typedData);
+    }
+
+    // Use hardware wallet signing
     if (!this.sessionId) {
       throw new LedgerError(
         'NO_SESSION',
@@ -162,4 +184,287 @@ export class Ledger {
       throw new LedgerError('SIGN_TYPED_DATA_FAILED', 'Failed to sign typed data');
     }
   };
+
+  public setWalletConnectProviderGetter = (providerGetter: () => Promise<any>) => {
+    this._getWalletConnectProvider = providerGetter;
+  };
+
+  public connectWalletConnect = async () => {
+    if (!this._getWalletConnectProvider) {
+      throw new LedgerError('WALLETCONNECT_NOT_CONFIGURED', 'WalletConnect is not configured');
+    }
+
+    const provider = await this._getWalletConnectProvider();
+    if (!provider) {
+      throw new LedgerError(
+        'WALLETCONNECT_PROVIDER_NOT_AVAILABLE',
+        'WalletConnect provider not available',
+      );
+    }
+
+    try {
+      // Check if there's an existing pairing (from getQrCode or previous connection)
+      const hasPairing = provider.client?.session?.map?.size > 0;
+
+      // Connect to WalletConnect
+      // If hasPairing is true, skipPairing will make connect() return immediately with existing session
+      // If hasPairing is false, connect() will wait for mobile wallet to confirm
+      await provider.connect({
+        namespaces: {
+          eip155: {
+            methods: [
+              'eth_sendTransaction',
+              'eth_signTransaction',
+              'eth_sign',
+              'eth_signTypedData',
+              'personal_sign',
+            ],
+            chains: ['eip155:1'], // Mainnet, can be extended
+            events: ['chainChanged', 'accountsChanged'],
+          },
+        },
+        skipPairing: hasPairing,
+      });
+
+      // Get session after connection (mobile wallet confirmed or existing session used)
+      const session = provider.session;
+      if (!session) {
+        throw new LedgerError(
+          'WALLETCONNECT_SESSION_NOT_AVAILABLE',
+          'WalletConnect session not available',
+        );
+      }
+
+      // Listen for session_delete event to handle remote disconnection
+      this._sessionDeleteHandler = () => {
+        this._walletConnectAccount = undefined;
+      };
+      provider.on('session_delete', this._sessionDeleteHandler);
+
+      const accounts = session.namespaces.eip155?.accounts || [];
+      if (accounts.length === 0) {
+        throw new LedgerError(
+          'WALLETCONNECT_NO_ACCOUNTS',
+          'No accounts found in WalletConnect session',
+        );
+      }
+
+      // Extract address from account string (format: eip155:1:0x...)
+      const address = accounts[0].split(':')[2];
+      if (!address) {
+        throw new LedgerError(
+          'WALLETCONNECT_INVALID_ACCOUNT',
+          'Invalid account format from WalletConnect',
+        );
+      }
+
+      this._walletConnectAccount = {
+        address,
+      };
+
+      return this._walletConnectAccount;
+    } catch (error: any) {
+      if (error instanceof LedgerError) {
+        throw error;
+      }
+      throw new LedgerError(
+        'WALLETCONNECT_CONNECTION_FAILED',
+        error?.message || 'Failed to connect via WalletConnect',
+      );
+    }
+  };
+
+  public disconnectWalletConnect = async () => {
+    if (this._getWalletConnectProvider) {
+      try {
+        const provider = await this._getWalletConnectProvider();
+        if (provider) {
+          // Remove session_delete listener
+          if (this._sessionDeleteHandler) {
+            provider.off('session_delete', this._sessionDeleteHandler);
+            this._sessionDeleteHandler = undefined;
+          }
+
+          if (provider.session) {
+            await provider.disconnect();
+          }
+        }
+      } catch {
+        // Ignore disconnect errors
+      }
+    }
+    this._walletConnectAccount = undefined;
+  };
+
+  public getWalletConnectAccount = (): Account | undefined => {
+    return this._walletConnectAccount;
+  };
+
+  /**
+   * Sign message using WalletConnect
+   * @private
+   */
+  private _signMessageWithWalletConnect = async (message: string): Promise<any> => {
+    if (!this._getWalletConnectProvider) {
+      throw new LedgerError('WALLETCONNECT_NOT_CONFIGURED', 'WalletConnect is not configured');
+    }
+
+    if (!this._walletConnectAccount?.address) {
+      throw new LedgerError('WALLETCONNECT_NO_ACCOUNTS', 'No WalletConnect account available');
+    }
+
+    try {
+      const provider = await this._getWalletConnectProvider();
+      if (!provider) {
+        throw new LedgerError(
+          'WALLETCONNECT_PROVIDER_NOT_AVAILABLE',
+          'WalletConnect provider not available',
+        );
+      }
+
+      const session = provider.session;
+      if (!session) {
+        throw new LedgerError(
+          'WALLETCONNECT_SESSION_NOT_AVAILABLE',
+          'WalletConnect session not available',
+        );
+      }
+
+      // Get chain ID from session (format: eip155:1)
+      const accounts = session.namespaces.eip155?.accounts || [];
+      if (accounts.length === 0) {
+        throw new LedgerError(
+          'WALLETCONNECT_NO_ACCOUNTS',
+          'No accounts found in WalletConnect session',
+        );
+      }
+
+      // Extract chain ID from account string (format: eip155:1:0x...)
+      const chainId = accounts[0].split(':')[1];
+      const chain = chainId ? `eip155:${chainId}` : undefined;
+
+      // Convert message to hex string if it's not already
+      let messageHex: string;
+      if (message.startsWith('0x')) {
+        messageHex = message;
+      } else {
+        // Convert string to hex using TextEncoder for browser compatibility
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(message);
+        messageHex = `0x${Array.from(bytes)
+          .map((byte) => byte.toString(16).padStart(2, '0'))
+          .join('')}`;
+      }
+
+      // Call personal_sign via WalletConnect
+      const signature = (await provider.request(
+        {
+          method: 'personal_sign',
+          params: [messageHex, this._walletConnectAccount.address],
+        },
+        chain,
+      )) as string;
+
+      return signature;
+    } catch (error: any) {
+      if (error instanceof LedgerError) {
+        throw error;
+      }
+      throw new LedgerError(
+        'SIGN_MESSAGE_FAILED',
+        error?.message || 'Failed to sign message via WalletConnect',
+      );
+    }
+  };
+
+  /**
+   * Sign typed data (EIP-712) using WalletConnect
+   * @private
+   */
+  private _signTypedDataWithWalletConnect = async (typedData: any): Promise<any> => {
+    if (!this._getWalletConnectProvider) {
+      throw new LedgerError('WALLETCONNECT_NOT_CONFIGURED', 'WalletConnect is not configured');
+    }
+
+    if (!this._walletConnectAccount?.address) {
+      throw new LedgerError('WALLETCONNECT_NO_ACCOUNTS', 'No WalletConnect account available');
+    }
+
+    try {
+      const provider = await this._getWalletConnectProvider();
+      if (!provider) {
+        throw new LedgerError(
+          'WALLETCONNECT_PROVIDER_NOT_AVAILABLE',
+          'WalletConnect provider not available',
+        );
+      }
+
+      const session = provider.session;
+      if (!session) {
+        throw new LedgerError(
+          'WALLETCONNECT_SESSION_NOT_AVAILABLE',
+          'WalletConnect session not available',
+        );
+      }
+
+      // Get chain ID from session (format: eip155:1)
+      const accounts = session.namespaces.eip155?.accounts || [];
+      if (accounts.length === 0) {
+        throw new LedgerError(
+          'WALLETCONNECT_NO_ACCOUNTS',
+          'No accounts found in WalletConnect session',
+        );
+      }
+
+      // Extract chain ID from account string (format: eip155:1:0x...)
+      const chainId = accounts[0].split(':')[1];
+      const chain = chainId ? `eip155:${chainId}` : undefined;
+
+      // Ensure chainId in domain is a number (not string) for proper serialization
+      const normalizedTypedData = {
+        ...typedData,
+        domain: {
+          ...typedData.domain,
+          chainId:
+            typeof typedData.domain?.chainId === 'string'
+              ? parseInt(typedData.domain.chainId, 10)
+              : typedData.domain?.chainId,
+        },
+      };
+
+      // Call eth_signTypedData via WalletConnect
+      // Note: WalletConnect v2 expects the second parameter to be a JSON string
+      // Some wallets may also support eth_signTypedData_v4
+      let signature: string;
+      try {
+        // Try eth_signTypedData_v4 first (preferred for WalletConnect v2)
+        signature = (await provider.request(
+          {
+            method: 'eth_signTypedData_v4',
+            params: [this._walletConnectAccount.address, JSON.stringify(normalizedTypedData)],
+          },
+          chain,
+        )) as string;
+      } catch (error: any) {
+        // Fallback to eth_signTypedData if v4 is not supported
+        signature = (await provider.request(
+          {
+            method: 'eth_signTypedData',
+            params: [this._walletConnectAccount.address, JSON.stringify(normalizedTypedData)],
+          },
+          chain,
+        )) as string;
+      }
+
+      return signature;
+    } catch (error: any) {
+      if (error instanceof LedgerError) {
+        throw error;
+      }
+      throw new LedgerError(
+        'SIGN_TYPED_DATA_FAILED',
+        error?.message || 'Failed to sign typed data via WalletConnect',
+      );
+    }
+  };
 }