@onekeyfe/hd-core 1.2.0-alpha.56 → 1.2.0-alpha.58

package/src/data-manager/DataManager.ts

@@ -26,6 +26,7 @@ import type {
   Features,
   IDeviceBLEFirmwareStatus,
   IDeviceFirmwareStatus,
+  IProtocolV2Resources,
   ITransportStatus,
   IVersionArray,
   RemoteConfigResponse,
@@ -112,6 +113,8 @@ export default class DataManager {
 
   static lastCheckTimestamp = 0;
 
+  static protocolV2ResourcesConfigError: Error | undefined;
+
   static getFirmwareStatus = (
     features: Features,
     firmwareType: EFirmwareType
@@ -400,6 +403,7 @@ export default class DataManager {
 
   static async load(settings: ConnectSettings): Promise<boolean> {
     this.settings = settings;
+    this.protocolV2ResourcesConfigError = undefined;
     if (!settings.fetchConfig) {
       return false;
     }
@@ -446,9 +450,20 @@ export default class DataManager {
 
     // 3. Apply config if available
     if (data) {
-      const pro2Resources = parseProtocolV2Resources(
-        (data.pro2 as { resources?: unknown } | undefined)?.resources
-      );
+      let pro2Resources: IProtocolV2Resources | undefined;
+      try {
+        pro2Resources = parseProtocolV2Resources(
+          (data.pro2 as { resources?: unknown } | undefined)?.resources
+        );
+      } catch (error) {
+        // Firmware resource metadata is not required for base communication. If the
+        // remote config is temporarily incomplete, disable this resource update only.
+        this.protocolV2ResourcesConfigError =
+          error instanceof Error ? error : new Error(String(error));
+        Log.warn('[DataConfig] Ignoring invalid Pro2 resources config:', error);
+      }
+      const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
+      const { resources: _unvalidatedResources, ...pro2Config } = enrichedPro2Config;
       Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
       this.deviceMap = {
         [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
@@ -458,7 +473,7 @@ export default class DataManager {
         [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
         [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
         [EDeviceType.Pro2]: {
-          ...this.enrichFirmwareReleaseInfo(data.pro2),
+          ...pro2Config,
           ...(pro2Resources ? { resources: pro2Resources } : undefined),
         },
       };
@@ -505,6 +520,12 @@ export default class DataManager {
         'Unable to refresh the latest remote config'
       );
     }
+    if (this.protocolV2ResourcesConfigError) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.NetworkError,
+        `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`
+      );
+    }
     this.lastCheckTimestamp = getTimeStamp();
   }
 

package/src/data-manager/TransportManager.ts

@@ -121,6 +121,12 @@ export default class TransportManager {
   }
 
   static setTransport(TransportConstructor: any, plugin?: LowlevelTransportSharedPlugin) {
+    if (typeof TransportConstructor !== 'function') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.TransportNotConfigured,
+        'Transport constructor is not available'
+      );
+    }
     const env = DataManager.getSettings('env');
     if (env === 'react-native') {
       /** Actually initializes the ReactNativeTransport */

package/src/device/DeviceCommands.ts

@@ -55,8 +55,10 @@ const DEVICE_SESSION_CALLS = new Set([
   'DeviceSessionAskPassphrase',
 ]);
 
-// Protocol V2 subcodes are domain-scoped, so cross-domain cancellation fallback
-// must use explicit firmware cancellation messages instead of a global number map.
+const PROTOCOL_V2_ACTION_CANCELLED_SUBCODE = 1;
+
+// Older Protocol V2 firmware may omit the cancellation subcode, so retain a
+// narrow message fallback for compatibility.
 const isProtocolV2ActionCancelledMessage = (message: string) =>
   /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
     message
@@ -499,6 +501,15 @@ export class DeviceCommands {
         const normalizedMessage = message?.trim() ?? '';
         const isProtocolV2ActionCancelledFailure =
           this.device.isProtocolV2() && isProtocolV2ActionCancelledMessage(normalizedMessage);
+        const isProtocolV2ActionCancelledSubcode =
+          this.device.isProtocolV2() && subcode === PROTOCOL_V2_ACTION_CANCELLED_SUBCODE;
+        // DeviceErrorCode currently reuses subcode 1 for Busy. Resolve that
+        // domain-specific exception before applying the common cancellation map.
+        const isProtocolV2DeviceBusyFailure =
+          this.device.isProtocolV2() &&
+          callType.startsWith('Device') &&
+          !DEVICE_SESSION_CALLS.has(callType) &&
+          subcode === DeviceErrorCode.DeviceError_Busy;
         const isLegacyProtocolV2LockedFailure =
           this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
         if (
@@ -556,8 +567,15 @@ export class DeviceCommands {
             subcode,
             firmwareMessage: message,
           });
+        } else if (isProtocolV2DeviceBusyFailure) {
+          error = ERRORS.TypedError(HardwareErrorCode.DeviceBusy, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
         } else if (
           subcode === DeviceErrorCode.DeviceError_ActionCancelled ||
+          isProtocolV2ActionCancelledSubcode ||
           isProtocolV2ActionCancelledFailure
         ) {
           error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled, message, {

package/src/device/DeviceConnector.ts

@@ -14,7 +14,7 @@ import type { OneKeyDeviceInfo as DeviceDescriptor, Transport } from '@onekeyfe/
 const Log = getLogger(LoggerNames.DeviceConnector);
 
 export default class DeviceConnector {
-  transport: Transport;
+  transport?: Transport;
 
   listenTimestamp = 0;
 
@@ -30,9 +30,21 @@ export default class DeviceConnector {
     DevicePool.setConnector(this);
   }
 
+  private getActiveTransport(): Transport {
+    const transport = this.transport ?? TransportManager.getTransport();
+    if (!transport) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.TransportNotConfigured,
+        'Device connector was created before transport initialization'
+      );
+    }
+    this.transport = transport;
+    return transport;
+  }
+
   async enumerate() {
     try {
-      const descriptors = await this.transport.enumerate();
+      const descriptors = await this.getActiveTransport().enumerate();
       this.upcoming = descriptors;
       this._reportDevicesChange();
       return { descriptors } as DeviceDescriptorDiff;
@@ -50,11 +62,10 @@ export default class DeviceConnector {
     let descriptors: DeviceDescriptor[];
 
     try {
+      const transport = this.getActiveTransport();
       Log.debug('Start listening', current);
       this.listenTimestamp = new Date().getTime();
-      descriptors = waitForEvent
-        ? await this.transport.listen(current)
-        : await this.transport.enumerate();
+      descriptors = waitForEvent ? await transport.listen(current) : await transport.enumerate();
       if (!this.listening) return; // do not continue if stop() was called
 
       this.upcoming = descriptors;
@@ -88,16 +99,17 @@ export default class DeviceConnector {
     Log.debug('acquire', path, session, expectedProtocol, protocolHint);
     const env = DataManager.getSettings('env');
     try {
+      const transport = this.getActiveTransport();
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await this.transport.acquire({
+        res = await transport.acquire({
           uuid: path,
           forceCleanRunPromise,
           expectedProtocol,
           protocolHint,
         });
       } else {
-        res = await this.transport.acquire({
+        res = await transport.acquire({
           path,
           previous: session ?? null,
           expectedProtocol,
@@ -105,7 +117,13 @@ export default class DeviceConnector {
         });
       }
       if (expectedProtocol) {
-        const detectedProtocol = this.transport.getProtocolType(path);
+        // The acquire response is the stable snapshot from this active probe. A delayed
+        // disconnect from an older generation may clear caches, so do not rely on cache alone.
+        const acquiredProtocol =
+          typeof res === 'object' && res !== null
+            ? (res as DeviceDescriptor).protocolType
+            : undefined;
+        const detectedProtocol = acquiredProtocol ?? transport.getProtocolType(path);
         if (detectedProtocol !== expectedProtocol) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
@@ -122,7 +140,7 @@ export default class DeviceConnector {
 
   async release(session: string, onclose: boolean) {
     try {
-      const res = await this.transport.release(session, onclose);
+      const res = await this.getActiveTransport().release(session, onclose);
       return res;
     } catch (error) {
       safeThrowError(error);
@@ -131,8 +149,9 @@ export default class DeviceConnector {
 
   async disconnect(session: string | undefined | null) {
     try {
-      if (this.transport.disconnect && !!session) {
-        await this.transport.disconnect(session);
+      const transport = this.getActiveTransport();
+      if (transport.disconnect && !!session) {
+        await transport.disconnect(session);
       }
     } catch (error) {
       safeThrowError(error);
@@ -140,10 +159,11 @@ export default class DeviceConnector {
   }
 
   promptDeviceAccess(): Promise<USBDevice | BluetoothDevice | null> {
-    if (!this.transport.promptDeviceAccess) {
+    const transport = this.getActiveTransport();
+    if (!transport.promptDeviceAccess) {
       return Promise.resolve(null);
     }
-    return this.transport.promptDeviceAccess();
+    return transport.promptDeviceAccess();
   }
 
   _reportDevicesChange() {