@onekeyfe/hd-core 1.2.0-alpha.32 → 1.2.0-alpha.34

package/src/protocols/protocol-v2/walletSession.ts

@@ -8,6 +8,21 @@ import { isDeviceLockedError } from './lockedError';
 import type { DeviceSessionGet } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
 
+const HOST_PASSPHRASE_MAX_BYTES = 50;
+
+const utf8ByteLength = (value: string): number | undefined => {
+  let length = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint >= 0xd800 && codePoint <= 0xdfff) return undefined;
+    if (codePoint <= 0x7f) length += 1;
+    else if (codePoint <= 0x7ff) length += 2;
+    else if (codePoint <= 0xffff) length += 3;
+    else length += 4;
+  }
+  return length;
+};
+
 export async function requestProtocolV2DeviceStatus(device: Device) {
   const { message } = await device.commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
   return message;
@@ -28,7 +43,7 @@ const getDeviceSession = async (device: Device, request: DeviceSessionGet) => {
   try {
     return await device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
   } catch (error) {
-    if (!isDeviceLockedError(error)) {
+    if (!isDeviceLockedError(error) || !request.session_id) {
       throw error;
     }
     await device.unlockDevice(DeviceSessionPinType.Main);
@@ -44,32 +59,47 @@ const askDevicePassphrase = async (device: Device, passphrase?: string) => {
       passphrase ? { passphrase, on_device: false } : { on_device: true }
     );
   try {
-    return await request();
+    await request();
   } catch (error) {
     if (!isDeviceLockedError(error)) {
       throw error;
     }
     await device.unlockDevice(DeviceSessionPinType.Main);
-    return request();
+    await request();
   }
+  await refreshProtocolV2DeviceStatus(device);
 };
 
-const selectDeviceSession = async (device: Device) => {
+const selectDeviceSession = async (device: Device, expectedPassphraseState?: string) => {
   const existsAttachPinUser = device.features?.attachToPinEnabled === true;
   const metadata = {
     source: 'wallet-session-coordinator' as const,
-    reason: 'open-wallet' as const,
+    reason: expectedPassphraseState ? ('session-recovery' as const) : ('open-wallet' as const),
+    ...(expectedPassphraseState ? { expectedPassphraseState } : {}),
   };
   const response = await device.commands.promptPassphrase(
     {
       existsAttachPinUser,
-      deviceOnly: true,
+      deviceOnly: false,
       ...metadata,
     },
     { cancelDeviceOnReject: false }
   );
-  const hasHostPassphrase =
-    typeof response.passphrase === 'string' && response.passphrase.length > 0;
+  const hostPassphrase =
+    typeof response.passphrase === 'string' ? response.passphrase.normalize('NFKD') : undefined;
+  const hasHostPassphrase = typeof hostPassphrase === 'string' && hostPassphrase.length > 0;
+  const hostPassphraseByteLength = hasHostPassphrase ? utf8ByteLength(hostPassphrase) : undefined;
+  if (
+    hasHostPassphrase &&
+    (hostPassphrase.includes('\0') ||
+      hostPassphraseByteLength === undefined ||
+      hostPassphraseByteLength > HOST_PASSPHRASE_MAX_BYTES)
+  ) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Host passphrase must contain 1 to ${HOST_PASSPHRASE_MAX_BYTES} valid UTF-8 bytes without NUL.`
+    );
+  }
   const selections = [
     hasHostPassphrase,
     response.passphraseOnDevice === true,
@@ -96,7 +126,7 @@ const selectDeviceSession = async (device: Device) => {
   }
 
   if (hasHostPassphrase) {
-    await askDevicePassphrase(device, response.passphrase);
+    await askDevicePassphrase(device, hostPassphrase);
     return getDeviceSession(device, {});
   }
 
@@ -115,7 +145,11 @@ export async function getProtocolV2WalletSession(
   }
 ) {
   if (options?.initSession) {
-    device.clearInternalState();
+    if (options.onlyMainPin) {
+      device.clearStandardInternalState?.();
+    } else {
+      device.clearInternalState();
+    }
     device.passphraseState = undefined;
   }
 
@@ -124,29 +158,42 @@ export async function getProtocolV2WalletSession(
   if (options?.onlyMainPin) {
     device.passphraseState = undefined;
   }
-  const expectedPassphraseState = options?.onlyMainPin
+  let expectedPassphraseState = options?.onlyMainPin
     ? undefined
     : options?.expectedPassphraseState ?? device.passphraseState;
 
-  if (device.features?.unlocked === false) {
-    await device.unlockDevice(DeviceSessionPinType.Main);
-  }
-
-  if (options?.onlyMainPin || device.getCurrentPassphraseProtection() === false) {
-    return {
-      passphraseState: undefined,
-      newSession: undefined,
-      unlockedAttachPin: device.features?.unlockedAttachPin ?? false,
-      resumed: false,
-    };
-  }
-
+  const cachedStandardSession = options?.onlyMainPin
+    ? device.getStandardInternalState?.()
+    : undefined;
   const cachedSessionId =
-    typeof device.getInternalState === 'function' ? device.getInternalState() : undefined;
+    !options?.onlyMainPin && typeof device.getInternalState === 'function'
+      ? device.getInternalState()
+      : undefined;
   let response;
   let resumed = false;
 
-  if (cachedSessionId && expectedPassphraseState) {
+  if (options?.onlyMainPin) {
+    expectedPassphraseState = cachedStandardSession?.passphraseState;
+    if (cachedStandardSession) {
+      try {
+        if (device.features?.unlockedAttachPin === true) {
+          await device.unlockDevice(DeviceSessionPinType.Main);
+        }
+        response = await getDeviceSession(device, {
+          session_id: cachedStandardSession.sessionId,
+        });
+        resumed = true;
+      } catch (error) {
+        device.clearStandardInternalState?.();
+        throw error;
+      }
+    }
+
+    if (!response) {
+      await device.unlockDevice(DeviceSessionPinType.Main);
+      response = await getDeviceSession(device, {});
+    }
+  } else if (cachedSessionId && expectedPassphraseState) {
     try {
       response = await getDeviceSession(device, { session_id: cachedSessionId });
       resumed = true;
@@ -161,28 +208,63 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
-    response = await selectDeviceSession(device);
+    response = await selectDeviceSession(device, expectedPassphraseState);
   }
 
-  const { message } = response;
+  let { message } = response;
   try {
     assertCompleteDeviceSession(message);
   } catch (error) {
-    device.clearInternalState();
+    if (options?.onlyMainPin) {
+      device.clearStandardInternalState?.();
+    } else {
+      device.clearInternalState();
+    }
     throw error;
   }
   if (expectedPassphraseState && expectedPassphraseState !== message.btc_test_address) {
-    device.clearInternalState();
-    throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+    resumed = false;
+    if (options?.onlyMainPin) {
+      device.clearStandardInternalState?.();
+      await device.unlockDevice(DeviceSessionPinType.Main);
+      response = await getDeviceSession(device, {});
+    } else {
+      device.clearInternalState();
+      response = await selectDeviceSession(device, expectedPassphraseState);
+    }
+    message = response.message;
+    try {
+      assertCompleteDeviceSession(message);
+    } catch (error) {
+      if (options?.onlyMainPin) {
+        device.clearStandardInternalState?.();
+      } else {
+        device.clearInternalState();
+      }
+      throw error;
+    }
+    if (expectedPassphraseState !== message.btc_test_address) {
+      if (options?.onlyMainPin) {
+        device.clearStandardInternalState?.();
+      } else {
+        device.clearInternalState();
+      }
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+    }
   }
 
-  device.updateInternalState(
+  const internalStateArgs = [
     true,
     message.btc_test_address,
     device.getCurrentDeviceId(),
     message.session_id,
-    options?.initSession ? null : cachedSessionId ?? null
-  );
+    options?.initSession ? null : cachedSessionId ?? null,
+  ] as const;
+  if (options?.onlyMainPin) {
+    device.updateInternalState(...internalStateArgs, 'standard');
+  } else {
+    device.updateInternalState(...internalStateArgs);
+  }
 
   return {
     passphraseState: message.btc_test_address,

package/src/types/api/openWalletSession.ts

@@ -36,7 +36,7 @@ export type OpenWalletSessionPayload = OpenWalletSessionPayloadBase &
   (
     | {
         walletType: 'standard';
-        passphraseState: null;
+        passphraseState: string | null;
       }
     | {
         walletType: 'hidden';

package/src/types/device.ts

@@ -1,4 +1,4 @@
-import { EDeviceType, type EFirmwareType } from '@onekeyfe/hd-shared';
+import { EDeviceType, type EFirmwareType, type HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 
 import type { IVersionArray } from './settings';
 import type { PROTO } from '../constants';
@@ -28,6 +28,8 @@ export type UnavailableCapabilities = { [key: string]: UnavailableCapability };
 
 export type KnownDevice = {
   connectId: string | null;
+  /** Protocol family confirmed by the transport's active probe. */
+  connectProtocol?: HardwareConnectProtocol;
   /**
    * Stable physical-device identity. Current SDK responses always include this
    * value; it remains optional in the type during the uuid compatibility window.
@@ -46,7 +48,7 @@ export type KnownDevice = {
   /** Current SDK/transport usage state for connection indicators. */
   status?: DeviceStatus;
   mode: EOneKeyDeviceMode;
-  features?: Features;
+  features: Features;
   /** Unified SDK device-state snapshot; features remains a legacy projection. */
   state?: DeviceState;
   unavailableCapabilities: UnavailableCapabilities;
@@ -61,6 +63,8 @@ export type KnownDevice = {
 
 export type SearchDevice = {
   connectId: string | null;
+  /** Protocol family confirmed by the transport's active probe. */
+  connectProtocol?: HardwareConnectProtocol;
   /**
    * Available after device initialization. BLE discovery does not connect to the
    * device, so it returns null until a later initialized device response. Current

package/src/types/params.ts

@@ -60,7 +60,8 @@ export interface CommonParams {
   usePreInitialize?: boolean;
 
   /**
-   * Expected transport protocol. If omitted, SDK probes Protocol V1 then Protocol V2.
+   * Strictly expected transport protocol. The SDK actively verifies this value and
+   * rejects a mismatch. If omitted, a cached protocol only influences probe order.
    */
   connectProtocol?: HardwareConnectProtocol;
 }

package/src/utils/deviceFeaturesCompat.ts

@@ -122,11 +122,18 @@ export const resolveDeviceBleName = (features?: DeviceFeaturesInput): string | n
 export const resolveDeviceFirmwareVersion = (features?: DeviceFeaturesInput): string | null => {
   if (!features) return null;
   const compatible = asCompatibleFeatures(features);
+  const bootloaderMode = compatible.bootloaderMode ?? compatible.bootloader_mode;
   return firstMeaningfulVersion(
     compatible.firmwareVersion,
     compatible.onekey_firmware_version,
     compatible.onekey_version,
-    versionFromParts(compatible.major_version, compatible.minor_version, compatible.patch_version)
+    bootloaderMode
+      ? null
+      : versionFromParts(
+          compatible.major_version,
+          compatible.minor_version,
+          compatible.patch_version
+        )
   );
 };
 

package/src/utils/pro2Wallpaper.ts

@@ -85,15 +85,9 @@ export function encodePro2Wallpaper(options: {
     for (let x = 0; x < width; x += 1) {
       const sourceOffset = (y * width + x) * 4;
       const thresholdIndex = ((y & 7) << 3) + (x & 7);
-      let red = Math.min(rgba[sourceOffset] + RED_THRESHOLD[thresholdIndex], 0xff) & 0xf8;
-      let green = Math.min(rgba[sourceOffset + 1] + GREEN_THRESHOLD[thresholdIndex], 0xff) & 0xfc;
-      let blue = Math.min(rgba[sourceOffset + 2] + BLUE_THRESHOLD[thresholdIndex], 0xff) & 0xf8;
-      if (!hasTransparency) {
-        const alpha = rgba[sourceOffset + 3];
-        red = (red * alpha) >> 8;
-        green = (green * alpha) >> 8;
-        blue = (blue * alpha) >> 8;
-      }
+      const red = Math.min(rgba[sourceOffset] + RED_THRESHOLD[thresholdIndex], 0xff) & 0xf8;
+      const green = Math.min(rgba[sourceOffset + 1] + GREEN_THRESHOLD[thresholdIndex], 0xff) & 0xfc;
+      const blue = Math.min(rgba[sourceOffset + 2] + BLUE_THRESHOLD[thresholdIndex], 0xff) & 0xf8;
       const rgb565 = ((red >> 3) << 11) | ((green >> 2) << 5) | (blue >> 3);
       const rgbOffset = 12 + y * stride + x * 2;
       data[rgbOffset] = rgb565 & 0xff;

package/tsconfig.type-tests.json

@@ -3,6 +3,10 @@
   "compilerOptions": {
     "noEmit": true
   },
-  "include": ["./src", "./__tests__/kaspa-public-types.type-test.ts"],
+  "include": [
+    "./src",
+    "./__tests__/kaspa-public-types.type-test.ts",
+    "./__tests__/known-device-public-types.type-test.ts"
+  ],
   "exclude": ["./dist", "../../node_modules"]
 }