Hardware Wallet Support

// From src/handlers/LedgerSigner.ts
export class LedgerSigner extends Signer {
  readonly path: string | undefined;        // Derivation path
  readonly privateKey: null | undefined;    // Always null (on device)
  readonly deviceId: string | undefined;    // Ledger device ID
  readonly isLedger: boolean | undefined;   // Flag for Ledger wallet
  
  readonly _eth: Promise<AppEth> | undefined; // Ethereum app connection
  
  constructor(provider: Provider, path: string, deviceId: string) {
    super();
    
    defineReadOnly(this, 'isLedger', true);
    defineReadOnly(this, 'privateKey', null);
    defineReadOnly(this, 'path', path);
    defineReadOnly(this, 'deviceId', deviceId);
    defineReadOnly(this, 'provider', provider || null);
    
    // Connect to Ledger Ethereum app
    defineReadOnly(
      this,
      '_eth',
      getEthApp(deviceId).then(
        ethApp => ethApp,
        error => Promise.reject(error)
      )
    );
  }
}

async signTransaction(transaction: TransactionRequest): Promise<string> {
  // Resolve transaction properties
  const tx = await resolveProperties(transaction);
  const baseTx: UnsignedTransaction = {
    chainId: tx.chainId || undefined,
    data: tx.data || undefined,
    gasLimit: tx.gasLimit || undefined,
    gasPrice: tx.gasPrice || undefined,
    nonce: tx.nonce ? Number(tx.nonce) : undefined,
    to: tx.to || undefined,
    value: tx.value || undefined,
  };
  
  // Serialize for Ledger
  const unsignedTx = serialize(baseTx).substring(2);
  
  // Sign on device with retry logic
  const signature = await this._retry(async (eth) => {
    return await eth.signTransaction(this.path, unsignedTx);
  });
  
  // Convert signature components to hex
  const r = sigComponentToHex(signature.r);
  const s = sigComponentToHex(signature.s);
  const v = signature.v;
  
  // Combine signature with transaction
  return serialize(baseTx, { r, s, v });
}

async signMessage(message: Bytes | string): Promise<string> {
  // Convert message to UTF-8 bytes
  const messageBytes = typeof message === 'string' 
    ? toUtf8Bytes(message) 
    : message;
  
  // Sign on Ledger
  const signature = await this._retry(async (eth) => {
    const sig = await eth.signPersonalMessage(
      this.path,
      hexlify(messageBytes).substring(2)
    );
    
    // Adjust v value for Ethereum
    sig.v -= 27;
    return sig;
  });
  
  // Convert to hex signature
  const r = sigComponentToHex(signature.r);
  const s = sigComponentToHex(signature.s);
  
  return joinSignature({ r, s, v: signature.v });
}

async _signTypedData(
  domain: any,
  types: any,
  value: any
): Promise<string> {
  // Encode typed data
  const domainSeparatorHex = TypedDataUtils.hashStruct(
    'EIP712Domain',
    domain,
    types,
    SignTypedDataVersion.V4
  ).toString('hex');
  
  const messageHashHex = TypedDataUtils.hashStruct(
    types.primaryType,
    value,
    types,
    SignTypedDataVersion.V4
  ).toString('hex');
  
  // Sign on Ledger
  const signature = await this._retry(async (eth) => {
    const sig = await ledgerService.signEIP712HashedMessage(
      this.path,
      domainSeparatorHex,
      messageHashHex
    );
    return sig;
  });
  
  const r = sigComponentToHex(signature.r);
  const s = sigComponentToHex(signature.s);
  const v = signature.v;
  
  return joinSignature({ r, s, v });
}

_retry<T = any>(
  callback: (eth: AppEth) => Promise<T>,
  timeout?: number
): Promise<T> {
  return new Promise(async (resolve, reject) => {
    // Set timeout if specified
    if (timeout && timeout > 0) {
      setTimeout(() => {
        reject(new RainbowError('Ledger: Signer timeout'));
      }, timeout);
    }
    
    const eth = await this._eth;
    if (!eth) {
      return reject(new Error('Ledger: Eth app not open'));
    }
    
    // Try up to 50 times with 100ms intervals (5 seconds total)
    for (let i = 0; i < 50; i++) {
      try {
        const result = await callback(eth);
        return resolve(result);
      } catch (error: any) {
        // Check for specific errors
        if (error.message?.includes('blind signing')) {
          return reject(
            new Error('Enable blind signing in Ledger Ethereum app')
          );
        }
        
        if (error.message?.includes('rejected')) {
          return reject(new Error('Transaction rejected by user'));
        }
        
        // Wait before retry
        await new Promise(resolve => setTimeout(resolve, 100));
      }
    }
    
    reject(new Error('Ledger: Maximum retries exceeded'));
  });
}