@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.21

package/src/device/DeviceCommands.ts

@@ -1,4 +1,11 @@
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import {
+  DeviceErrorCode,
+  type FailureType,
+  type Messages,
+  type Transport,
+  type TransportCallOptions,
+} from '@onekeyfe/hd-transport';
 
 import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
@@ -12,12 +19,6 @@ import {
 } from '../utils/tracing';
 
 import type { Device } from './Device';
-import type {
-  FailureType,
-  Messages,
-  Transport,
-  TransportCallOptions,
-} from '@onekeyfe/hd-transport';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
@@ -51,11 +52,16 @@ const HIGH_VOLUME_DEBUG_CALLS = new Set([
   'FirmwareUpload',
   'ResourceAck',
 ]);
+const SENSITIVE_DEBUG_CALLS = new Set(['DeviceSessionGet']);
 
 function shouldReduceDebugForCall(type: string) {
   return HIGH_VOLUME_DEBUG_CALLS.has(type);
 }
 
+function shouldBlockDebugForCall(type: string) {
+  return SENSITIVE_DEBUG_CALLS.has(type);
+}
+
 function getBinaryByteLength(value: unknown): number | undefined {
   if (value instanceof ArrayBuffer) {
     return value.byteLength;
@@ -98,6 +104,12 @@ function sanitizeDebugPayload(value: unknown, key = '', depth = 0): unknown {
     return summarizeRedactedData(value);
   }
 
+  // Redact passphrase-bearing keys as defense in depth so wallet identifiers and
+  // host passphrases cannot reach diagnostic logs through a future call path.
+  if (key && /passphrase/i.test(key)) {
+    return '[redacted passphrase]';
+  }
+
   const byteLength = getBinaryByteLength(value);
   if (byteLength !== undefined) {
     return `[binary: ${byteLength} bytes]`;
@@ -141,10 +153,9 @@ function sanitizeDebugPayload(value: unknown, key = '', depth = 0): unknown {
 }
 
 /**
- * 交互式 Ack（ButtonAck / PinMatrixAck / PassphraseAck 等）不应继承原调用的
- * timeoutMs：设备在等待用户操作（确认、输入 PIN/passphrase），思考时间不可预估，
- * 沿用业务调用的超时会把用户操作截断。仅保留 expectedTypes / intermediateTypes
- * 等与响应类型相关的选项。
+ * Interactive acknowledgements must not inherit timeoutMs from the original call.
+ * User confirmation and PIN/passphrase entry have unbounded think time. Preserve only
+ * response-related options such as expectedTypes and intermediateTypes.
  */
 const stripInteractiveAckTimeout = (
   options?: TransportCallOptions
@@ -440,6 +451,7 @@ export class DeviceCommands {
         'PinMatrixAck',
         'PassphraseAck',
         'Cancel',
+        'DeviceSessionGet',
         'BixinPinInputOnDevice',
         'FilesystemFileRead',
         'FilesystemFileWrite',
@@ -450,7 +462,7 @@ export class DeviceCommands {
         'FirmwareUpload',
         'ResourceAck',
       ] as any;
-      if (!skipTypes.includes(type) && msg) {
+      if (!skipTypes.includes(type) && !shouldBlockDebugForCall(type) && msg) {
         // Use debug channel to avoid noise escalation
         Log.debug('[DeviceCommands] [typedCall] Sending payload', type, sanitizeDebugPayload(msg));
       }
@@ -475,12 +487,14 @@ export class DeviceCommands {
       // throw bridge network error
       if (error instanceof HardwareError) {
         if (error.errorCode === HardwareErrorCode.ResponseUnexpectTypeError) {
-          Log.debug('[DeviceCommands] [typedCall] Unexpected response type', {
-            request: type,
-            expected: resType,
-            received: response.type,
-            response: sanitizeDebugPayload(response.message),
-          });
+          if (!shouldBlockDebugForCall(type)) {
+            Log.debug('[DeviceCommands] [typedCall] Unexpected response type', {
+              request: type,
+              expected: resType,
+              received: response.type,
+              response: sanitizeDebugPayload(response.message),
+            });
+          }
           // Do not intercept CallMethodError
           // Do not intercept “assertType: Response of unexpected type” error
           // Blocking the above two messages will not know what the specific error message is, and the specific error should be handled by the subsequent business logic.
@@ -519,8 +533,8 @@ export class DeviceCommands {
     options?: TransportCallOptions
   ): Promise<DefaultMessageResponse> {
     try {
-      if (shouldReduceDebugForCall(callType)) {
-        // 高频文件写入每个 chunk 都会经过这里，避免 debug log 反向拖慢传输。
+      if (shouldReduceDebugForCall(callType) || shouldBlockDebugForCall(callType)) {
+        // Skip high-volume or security-sensitive response payloads.
       } else if (DataManager.getSettings('env') === 'react-native') {
         Log.debug('_filterCommonTypes: ', JSON.stringify(sanitizeDebugPayload(res)));
       } else {
@@ -532,8 +546,9 @@ export class DeviceCommands {
 
     this.device.clearCancelableAction();
     if (res.type === 'Failure') {
-      const { code, message } = res.message as {
+      const { code, subcode, message } = res.message as {
         code?: string | FailureType;
+        subcode?: number;
         message?: string;
       };
       let error: HardwareError | null = null;
@@ -577,8 +592,31 @@ export class DeviceCommands {
       }
 
       if (code === 'Failure_ProcessError') {
-        // Handle firmware verification failures
+        const normalizedMessage = message?.trim() ?? '';
+        const isLegacyProtocolV2ActionCancelledFailure =
+          this.device.isProtocolV2() &&
+          /^(?:cancelled on device|confirm dismissed)$/i.test(normalizedMessage);
+        const isLegacyProtocolV2LockedFailure =
+          this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
         if (
+          subcode === DeviceErrorCode.DeviceError_ActionCancelled ||
+          isLegacyProtocolV2ActionCancelledFailure
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
+          subcode === DeviceErrorCode.DeviceError_DeviceLocked ||
+          isLegacyProtocolV2LockedFailure
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.DeviceLocked, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
           message?.includes('Bootloader file verify failed') ||
           message?.includes('verify failed')
         ) {
@@ -655,7 +693,7 @@ export class DeviceCommands {
 
     if (res.type === 'PassphraseRequest') {
       const existsAttachPinUser = res.message.exists_attach_pin_user;
-      return this._promptPassphrase({
+      return this.promptPassphrase({
         existsAttachPinUser,
       }).then(response => {
         const { passphrase, passphraseOnDevice, attachPinOnDevice } = response;
@@ -753,10 +791,27 @@ export class DeviceCommands {
     });
   }
 
-  _promptPassphrase(options: PassphraseRequestPayload) {
+  promptPassphrase(
+    options: PassphraseRequestPayload,
+    promptOptions: { cancelDeviceOnReject?: boolean } = {}
+  ) {
     return new Promise<PassphrasePromptResponse>((resolve, reject) => {
-      const cancelAndReject = (_error?: Error) =>
-        cancelDeviceInPrompt(this.device, false)
+      const cancelAndReject = (_error?: Error) => {
+        const rejectWithCancelledError = () => {
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.CallQueueActionCancelled,
+              `${DEVICE.PASSPHRASE} canceled`
+            )
+          );
+        };
+
+        if (promptOptions.cancelDeviceOnReject === false) {
+          rejectWithCancelledError();
+          return Promise.resolve();
+        }
+
+        return cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
               HardwareErrorCode.CallQueueActionCancelled,
@@ -773,6 +828,7 @@ export class DeviceCommands {
           .catch(error => {
             reject(error);
           });
+      };
 
       if (this.device.listenerCount(DEVICE.PASSPHRASE) > 0) {
         this.device.setCancelableAction(cancelAndReject);

package/src/device/DeviceFeaturesState.ts

@@ -0,0 +1,25 @@
+import type { Features } from '../types';
+
+/**
+ * Merge a field-level device-state patch.
+ *
+ * `undefined` means the response omitted a field and preserves the cache; `null`
+ * means the device explicitly returned an empty value and must be cached. Callers
+ * provide complete object fields such as raw; this function does not deep-merge.
+ */
+export function mergeDeviceFeaturesPatch(previous: Features, patch: Partial<Features>): Features {
+  let next = previous;
+
+  for (const [key, value] of Object.entries(patch) as Array<
+    [keyof Features, Features[keyof Features] | undefined]
+  >) {
+    if (value !== undefined && !Object.is(previous[key], value)) {
+      if (next === previous) {
+        next = { ...previous };
+      }
+      (next as Record<keyof Features, Features[keyof Features]>)[key] = value;
+    }
+  }
+
+  return next;
+}

package/src/device/DevicePool.ts

@@ -106,26 +106,32 @@ export class DevicePool extends EventEmitter {
         if (exist) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
+          await this._refreshRuntimeState(device, initOptions);
           devices[connectId] = device;
           deviceList.push(device);
-          await this._checkDevicePool(initOptions);
+          await this._checkDevicePool(initOptions, connectId);
           return { devices, deviceList };
         }
         Log.debug('found device in cache, but path is different: ', connectId);
       }
     }
 
-    for await (const descriptor of descriptorList) {
+    const matchedDescriptor = connectId
+      ? descriptorList.find(descriptor => descriptor.path === connectId)
+      : undefined;
+    const descriptorsToInitialize = matchedDescriptor ? [matchedDescriptor] : descriptorList;
+
+    for await (const descriptor of descriptorsToInitialize) {
       const device = await this._createDevice(descriptor, initOptions);
 
-      const uuid = device.getCurrentSerialNo();
-      if (uuid) {
-        if (this.devicesCache[uuid]) {
-          const cache = this.devicesCache[uuid];
+      const connectId = device.getConnectId();
+      if (connectId) {
+        if (this.devicesCache[connectId]) {
+          const cache = this.devicesCache[connectId];
           cache.updateDescriptor(descriptor, true);
         }
-        this.devicesCache[uuid] = device;
-        devices[uuid] = device;
+        this.devicesCache[connectId] = device;
+        devices[connectId] = device;
       }
 
       deviceList.push(device);
@@ -133,7 +139,7 @@ export class DevicePool extends EventEmitter {
     // Log.debug('get devices result : ', devices, deviceList);
     // console.log('device poll -> connected: ', this.connectedPool);
     // console.log('device poll -> disconnected: ', this.disconnectPool);
-    await this._checkDevicePool(initOptions);
+    await this._checkDevicePool(initOptions, matchedDescriptor ? connectId : undefined);
     return { devices, deviceList };
   }
 
@@ -151,32 +157,73 @@ export class DevicePool extends EventEmitter {
       device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
       await device.connect(initOptions?.connectProtocol);
-      await device.initialize(initOptions);
-      await device.release();
+      try {
+        await device.initialize(initOptions);
+        if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {
+          await this._refreshProtocolV2DiscoveryState(device);
+        }
+      } finally {
+        await device.release();
+      }
     }
     return device;
   }
 
-  static async _checkDevicePool(initOptions?: InitOptions) {
-    await this._sendConnectMessage(initOptions);
+  static async _refreshRuntimeState(device: Device, initOptions?: InitOptions) {
+    if (!initOptions?.refreshRuntimeState || !device.isProtocolV2()) return;
+    let refreshError: unknown;
+    await device.run(
+      async () => {
+        try {
+          await this._refreshProtocolV2DiscoveryState(device);
+        } catch (error) {
+          // Device.run releases after the callback; then propagate the actual read error.
+          refreshError = error;
+        }
+      },
+      { connectProtocol: initOptions.connectProtocol }
+    );
+    if (refreshError instanceof Error) throw refreshError;
+    if (refreshError) throw new Error(String(refreshError));
+  }
+
+  /**
+   * Device lists require live mode and name data. A status failure remains a connection
+   * error; settings only supplies a label, so its failure retains the existing name.
+   * Device.getDeviceState skips unsupported status/settings calls in loader mode.
+   */
+  static async _refreshProtocolV2DiscoveryState(device: Device) {
+    await device.getDeviceState({ refreshSections: ['status'] });
+    try {
+      await device.getDeviceState({ refreshSections: ['settings'] });
+    } catch (error) {
+      Log.debug('Unable to refresh Protocol V2 device label during discovery', error);
+    }
+  }
+
+  static async _checkDevicePool(initOptions?: InitOptions, connectId?: string) {
+    await this._sendConnectMessage(initOptions, connectId);
     this._sendDisconnectMessage();
   }
 
-  static async _sendConnectMessage(initOptions?: InitOptions) {
+  static async _sendConnectMessage(initOptions?: InitOptions, connectId?: string) {
     for (let i = this.connectedPool.length - 1; i >= 0; i--) {
       const descriptor = this.connectedPool[i];
-      const device = await this._createDevice(descriptor, initOptions);
-      Log.debug('emit DEVICE.CONNECT: ', device?.features);
-      this.emitter.emit(DEVICE.CONNECT, device);
-      this.connectedPool.splice(i, 1);
+      if (!connectId || descriptor.path === connectId) {
+        const device = await this._createDevice(descriptor, initOptions);
+        Log.debug('emit DEVICE.CONNECT: ', device?.features);
+        this.emitter.emit(DEVICE.CONNECT, device);
+        this.connectedPool.splice(i, 1);
+      }
     }
   }
 
   static _sendDisconnectMessage() {
     for (let i = this.disconnectPool.length - 1; i >= 0; i--) {
-      const descriptor = this.connectedPool[i];
+      const descriptor = this.disconnectPool[i];
       const device = descriptor?.path ? this.getDeviceByPath(descriptor.path) : null;
       if (device) {
+        device.markTransportDisconnected();
         this.emitter.emit(DEVICE.DISCONNECT, device);
       }
       this.disconnectPool.splice(i, 1);
@@ -216,6 +263,7 @@ export class DevicePool extends EventEmitter {
       }
 
       Log.debug('emit DEVICE.DISCONNECT: ', device.features);
+      device.markTransportDisconnected();
       this.emitter.emit(DEVICE.DISCONNECT, device);
     });
   }