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

package/src/api/helpers/protocolV2FileWrite.ts

@@ -152,6 +152,12 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         options.throwIfAborted?.();
       }
     }
+    if (!response) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'FilesystemFileWrite completed without a response'
+      );
+    }
     options.throwIfAborted?.();
     lastMessage = response.message;
     const rawProcessedByte = response.message?.processed_byte;

package/src/api/index.ts

@@ -48,24 +48,6 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
-// Protocol V2 development APIs. These remain public while Pro2 integration is in development.
-export { default as deviceInfoGet } from './protocol-v2/DeviceInfoGet';
-export { default as deviceStatusGet } from './protocol-v2/DeviceStatusGet';
-export { default as protocolInfoRequest } from './protocol-v2/ProtocolInfoRequest';
-export { default as ping } from './protocol-v2/Ping';
-export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
-export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
-export { default as deviceFactoryInfoSet } from './protocol-v2/DeviceFactoryInfoSet';
-export { default as deviceFactoryInfoGet } from './protocol-v2/DeviceFactoryInfoGet';
-export { default as filesystemPermissionFix } from './protocol-v2/FilesystemPermissionFix';
-export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
-export { default as fileRead } from './FileRead';
-export { default as fileWrite } from './FileWrite';
-export { default as fileDelete } from './FileDelete';
-export { default as dirList } from './DirList';
-export { default as dirMake } from './DirMake';
-export { default as dirRemove } from './DirRemove';
-export { default as pathInfo } from './PathInfo';
 export { default as uploadPortfolio } from './UploadPortfolio';
 
 export { default as cipherKeyValue } from './CipherKeyValue';

package/src/api/nexa/NexaSignTransaction.ts

@@ -9,6 +9,8 @@ import type { TypedCall } from '@onekeyfe/hd-transport';
 import type { DeviceFirmwareRange, NexaSignTransactionParams, NexaSignature } from '../../types';
 
 export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
+  checkDeviceId = true;
+
   hasBundle = false;
 
   init() {

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -71,7 +71,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
     this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
     this.requireProtocolV2 = true;
-    this.unlockPolicy = 'retry-on-locked';
+    this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
   }

package/src/core/index.ts

@@ -1262,6 +1262,7 @@ const onDevicePassphraseHandler = async (
       device: device.toMessageObject() as KnownDevice,
       passphraseState: device.passphraseState,
       existsAttachPinUser: requestPayload.existsAttachPinUser,
+      deviceOnly: requestPayload.deviceOnly,
       source: requestPayload.source,
       reason: requestPayload.reason,
       expectedPassphraseState: requestPayload.expectedPassphraseState,

package/src/data/messages/messages-protocol-v2.json

@@ -485,6 +485,7 @@
         "MessageType_DeviceSessionGet": 60606,
         "MessageType_DeviceSession": 60607,
         "MessageType_DeviceSessionAskPin": 60608,
+        "MessageType_DeviceSessionAskPassphrase": 60609,
         "MessageType_FilesystemPermissionFix": 60800,
         "MessageType_FilesystemPathInfo": 60801,
         "MessageType_FilesystemPathInfoQuery": 60802,
@@ -11744,7 +11745,15 @@
       }
     },
     "ProtocolInfoRequest": {
-      "fields": {}
+      "fields": {
+        "eventless_wallet_session": {
+          "type": "bool",
+          "id": 1,
+          "options": {
+            "default": false
+          }
+        }
+      }
     },
     "ProtocolInfo": {
       "fields": {
@@ -12427,6 +12436,16 @@
         }
       }
     },
+    "DeviceSessionErrorCode": {
+      "values": {
+        "DeviceSessionError_None": 0,
+        "DeviceSessionError_UserCancelled": 1,
+        "DeviceSessionError_InvalidSession": 2,
+        "DeviceSessionError_AttachPinUnavailable": 3,
+        "DeviceSessionError_PassphraseDisabled": 4,
+        "DeviceSessionError_Busy": 5
+      }
+    },
     "DeviceSessionGet": {
       "fields": {
         "session_id": {
@@ -12447,7 +12466,22 @@
         }
       }
     },
+    "DeviceSessionPinType": {
+      "values": {
+        "Any": 1,
+        "Main": 2,
+        "AttachToPin": 3
+      }
+    },
     "DeviceSessionAskPin": {
+      "fields": {
+        "type": {
+          "type": "DeviceSessionPinType",
+          "id": 1
+        }
+      }
+    },
+    "DeviceSessionAskPassphrase": {
       "fields": {}
     },
     "DeviceSessionAskPin_FailureSubCodes": {

package/src/data-manager/DataManager.ts

@@ -399,7 +399,17 @@ export default class DataManager {
 
   static async load(settings: ConnectSettings) {
     this.settings = settings;
-    if (!settings.fetchConfig) {
+    const manifestMode =
+      settings.firmwareManifestMode ?? (settings.fetchConfig ? 'sdk-managed' : undefined);
+    if (settings.preloadedConfig) {
+      this.applyRemoteConfig(settings.preloadedConfig);
+      Log.log('[DataConfig] Preloaded firmware config loaded');
+      return;
+    }
+    if (manifestMode === 'external-only') {
+      throw new Error('External firmware config snapshot is required');
+    }
+    if (manifestMode !== 'sdk-managed') {
       return;
     }
 
@@ -409,60 +419,50 @@ export default class DataManager {
 
     const urlWithCache = `${url}?noCache=${getTimeStamp()}`;
     let data: RemoteConfigResponse | null = null;
-    let fetchMethod: 'configFetcher' | 'axios' | 'none' = 'none';
-
-    // 1. Try custom configFetcher first (client-side IP direct connection support)
     if (settings.configFetcher) {
-      Log.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
+      Log.debug('[DataConfig] Trying client configFetcher...');
       try {
         data = await settings.configFetcher(urlWithCache);
-        if (data) {
-          fetchMethod = 'configFetcher';
-          Log.log('[DataConfig] ConfigFetcher success');
-        } else {
-          Log.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
-        }
       } catch (e) {
-        Log.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
+        Log.warn('[DataConfig] Client configFetcher failed:', e);
       }
     }
-
-    // 2. Fallback to default axios request
     if (!data) {
-      Log.debug('[DataConfig] Trying axios (SDK default fetcher)...');
+      Log.debug('[DataConfig] Trying SDK-managed config request...');
       try {
         const response = await axios.get<RemoteConfigResponse>(urlWithCache, {
           // because of iframe timeout is 10000
           timeout: 7000,
         });
         data = response.data;
-        fetchMethod = 'axios';
-        Log.log('[DataConfig] Axios fetch success');
+        Log.log('[DataConfig] SDK-managed config request succeeded');
       } catch (e) {
-        Log.warn('[DataConfig] Axios fetch error:', e);
+        Log.warn('[DataConfig] SDK-managed config request failed:', e);
       }
     }
 
-    // 3. Apply config if available
     if (data) {
-      Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
-      this.deviceMap = {
-        [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
-        [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
-        [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
-        [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
-        [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
-        [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-        [EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
-      };
-      this.assets = {
-        bridge: data.bridge,
-      };
+      this.applyRemoteConfig(data);
     } else {
-      Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
+      Log.warn('[DataConfig] SDK-managed config request failed, using built-in default config');
     }
   }
 
+  private static applyRemoteConfig(data: RemoteConfigResponse) {
+    this.deviceMap = {
+      [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
+      [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
+      [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
+      [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
+      [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
+      [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
+      [EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
+    };
+    this.assets = {
+      bridge: data.bridge,
+    };
+  }
+
   static updateEnv(newEnv: ConnectSettings['env']) {
     if (this.settings) {
       const prevEnv = this.settings.env;

package/src/data-manager/connectSettings.ts

@@ -115,10 +115,21 @@ export const parseConnectSettings = (input: Partial<ConnectSettings> = {}) => {
     settings.fetchConfig = input.fetchConfig;
   }
 
+  if (
+    input.firmwareManifestMode === 'sdk-managed' ||
+    input.firmwareManifestMode === 'external-only'
+  ) {
+    settings.firmwareManifestMode = input.firmwareManifestMode;
+  }
+
   if (input.configFetcher) {
     settings.configFetcher = input.configFetcher;
   }
 
+  if (input.preloadedConfig) {
+    settings.preloadedConfig = input.preloadedConfig;
+  }
+
   return settings;
 };
 

package/src/device/Device.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 import semver from 'semver';
-import { DeviceRebootType, Enum_Capability } from '@onekeyfe/hd-transport';
+import { DeviceRebootType, DeviceSessionPinType, Enum_Capability } from '@onekeyfe/hd-transport';
 import {
   EDeviceType,
   ERRORS,
@@ -153,7 +153,8 @@ export interface Device {
  * This allows short-lived processes (e.g. CLI) to restore a previously
  * obtained session, avoiding the need to re-enter passphrase on every
  * invocation. The session must have been obtained from a prior
- * getPassphraseState() call on the same device.
+ * wallet-session call on the same device. This compatibility hook is intended
+ * for a trusted CLI process restoring its own OS-keychain entry.
  *
  * @param deviceId - The device's device_id (from features)
  * @param passphraseState - The passphrase state token
@@ -222,24 +223,7 @@ export class Device extends EventEmitter {
 
   get features(): Features | undefined {
     if (!this.state) return undefined;
-    const features = projectFeatures(this.state);
-    const sessionCacheDeviceKey =
-      this.state.identity.deviceId ||
-      (this.isProtocolV2()
-        ? this.originalDescriptor.path || this.originalDescriptor.id
-        : undefined);
-    const sessionId =
-      sessionCacheDeviceKey && this.passphraseState
-        ? deviceWalletSessionStore.get(sessionCacheDeviceKey, this.passphraseState)
-        : undefined;
-    return sessionId
-      ? {
-          ...features,
-          sessionId,
-          session_id: sessionId,
-          passphraseState: this.passphraseState,
-        }
-      : features;
+    return projectFeatures(this.state);
   }
 
   set features(features: Features | undefined) {
@@ -334,12 +318,14 @@ export class Device extends EventEmitter {
       instanceId: this.instanceId,
       createdAt: this.createdAt,
       deviceType,
-      /** ID for current seeds, will clear after replace a new seed at device */
+      /** Wallet-lifecycle ID; changes after the device is wiped or reinitialized. */
       deviceId,
       path: this.originalDescriptor?.path,
       bleName,
-      name: bleName || label || `OneKey ${deviceType?.toUpperCase()}`,
-      label: label || 'OneKey',
+      name: label || bleName || `OneKey ${deviceType?.toUpperCase()}`,
+      // Keep the legacy top-level field string-compatible while preserving
+      // the canonical nullable value at state.identity.label.
+      label: label ?? '',
       mode: this.getMode(),
       features,
       state,
@@ -691,16 +677,14 @@ export class Device extends EventEmitter {
     const deviceId = _deviceId || this.getCurrentDeviceId();
     if (deviceId) return deviceId;
     if (this.isProtocolV2()) {
-      return this.originalDescriptor.path || this.originalDescriptor.id;
+      return this.originalDescriptor.path;
     }
     return undefined;
   }
 
   private reconcileSessionCacheDeviceIdentity(previousDeviceId?: string) {
     deviceWalletSessionStore.reconcileDeviceIdentity({
-      temporaryKey: this.isProtocolV2()
-        ? this.originalDescriptor.path || this.originalDescriptor.id
-        : undefined,
+      temporaryKey: this.isProtocolV2() ? this.originalDescriptor.path : undefined,
       previousDeviceId,
       nextDeviceId: this.getCurrentDeviceId(),
     });
@@ -806,43 +790,55 @@ export class Device extends EventEmitter {
       return;
     }
 
-    // Log.debug('initialize param:', options);
+    try {
+      const callInitialize = async (payload: Record<string, unknown>, initSession?: boolean) => {
+        const initStartAt = Date.now();
+        const { message } = await this.commands.typedCall('Initialize', 'Features', payload, {
+          // iOS BLE bound devices can need close to 20 seconds.
+          timeoutMs: 25 * 1000,
+        });
+        this.setLastInitializeDuration(Date.now() - initStartAt);
+        this._updateFeatures(message, initSession);
+        await TransportManager.reconfigure(this.features);
+      };
 
-    this.passphraseState = options?.passphraseState;
+      const expectedDeviceId = options?.deviceId;
+      if (expectedDeviceId) {
+        // Establish the live physical identity before sending wallet-bound state.
+        this.passphraseState = undefined;
+        await callInitialize({ is_contains_attach: true });
+        if (!this.checkDeviceId(expectedDeviceId)) {
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+      }
 
-    if (options?.initSession) {
-      this.clearInternalState(options?.deviceId);
-    }
+      this.passphraseState = options?.passphraseState;
 
-    const internalState = this.getInternalState(options?.deviceId);
-    const payload: any = {};
-    if (internalState) {
-      payload.session_id = internalState;
-    }
+      if (options?.initSession) {
+        this.clearInternalState(options?.deviceId);
+      }
 
-    if (options?.deriveCardano) {
-      payload.derive_cardano = true;
-    }
-    payload.passphrase_state = options?.passphraseState;
-    payload.is_contains_attach = true;
+      const internalState = this.getInternalState(options?.deviceId);
+      const payload: Record<string, unknown> = {
+        passphrase_state: options?.passphraseState,
+        is_contains_attach: true,
+      };
+      if (internalState) {
+        payload.session_id = internalState;
+      }
+      if (options?.deriveCardano) {
+        payload.derive_cardano = true;
+      }
 
-    const initStartAt = Date.now();
-    try {
-      // @ts-expect-error
-      const { message } = await Promise.race([
-        this.commands.typedCall('Initialize', 'Features', payload),
-        new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
-            // iOS ble bound device timeout 20s
-          }, 25 * 1000);
-        }),
-      ]);
-
-      const initCostMs = Date.now() - initStartAt;
-      this.setLastInitializeDuration(initCostMs);
-      this._updateFeatures(message, options?.initSession);
-      await TransportManager.reconfigure(this.features);
+      const requiresWalletInitialize =
+        !expectedDeviceId ||
+        Boolean(internalState) ||
+        Boolean(options?.passphraseState) ||
+        options?.deriveCardano === true ||
+        options?.initSession === true;
+      if (requiresWalletInitialize) {
+        await callInitialize(payload, options?.initSession);
+      }
     } catch (error) {
       Log.error('Initialization failed:', error);
       throw error;
@@ -972,10 +968,6 @@ export class Device extends EventEmitter {
         ? protoFeatures
         : buildProtocolV1FeaturesPayload(protoFeatures, this.features);
 
-    // GetFeatures doesn't return 'session_id'
-    if (this.features?.sessionId && !feat.sessionId) {
-      feat.sessionId = this.features.sessionId;
-    }
     feat.unlocked = feat.unlocked ?? true;
 
     feat = fixFeaturesFirmwareVersion(feat);
@@ -1078,6 +1070,22 @@ export class Device extends EventEmitter {
     this.clearPreInitialized();
   }
 
+  invalidateAfterWipe() {
+    const deviceId = this.getCurrentDeviceId();
+    if (deviceId) {
+      deviceWalletSessionStore.deleteDevice(deviceId);
+    }
+    if (this.isProtocolV2() && this.originalDescriptor.path !== deviceId) {
+      deviceWalletSessionStore.deleteDevice(this.originalDescriptor.path);
+      this.protocolV2StateNeedsReload = true;
+    }
+
+    this.passphraseState = undefined;
+    this.stateStore = new DeviceStateStore();
+    this.clearPreInitialized();
+    this.needReloadDevice = true;
+  }
+
   markProtocolV2Reboot(rebootType: DeviceRebootType) {
     if (!this.isProtocolV2()) return;
 
@@ -1428,12 +1436,17 @@ export class Device extends EventEmitter {
     };
   }
 
-  async unlockDevice() {
+  async unlockDevice(pinType: DeviceSessionPinType = DeviceSessionPinType.Main) {
     if (this.isProtocolV2()) {
       try {
-        await this.commands.typedCall('DeviceSessionAskPin', 'Success', undefined, {
-          timeoutMs: 120_000,
-        });
+        await this.commands.typedCall(
+          'DeviceSessionAskPin',
+          'Success',
+          { type: pinType },
+          {
+            timeoutMs: 120_000,
+          }
+        );
       } catch (error) {
         const errorText =
           error instanceof Error