@onekeyfe/hd-core 1.2.2-alpha.100 → 1.2.2-alpha.11

package/src/api/OpenWalletSession.ts

@@ -29,6 +29,12 @@ const wasResumed = (session: unknown) =>
   'resumed' in session &&
   (session as { resumed?: unknown }).resumed === true;
 
+const wasWalletStatusRefreshed = (session: unknown) =>
+  !!session &&
+  typeof session === 'object' &&
+  'walletStatusRefreshed' in session &&
+  (session as { walletStatusRefreshed?: unknown }).walletStatusRefreshed === true;
+
 const requireHiddenWalletResponse = (session: { passphraseState?: string }) => {
   if (!session.passphraseState) {
     throw ERRORS.TypedError(
@@ -87,12 +93,20 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
+    this.protocolV2PreUnlockPinType =
+      this.params.mode === OpenWalletSessionMode.SelectHidden
+        ? DeviceSessionPinType.Any
+        : DeviceSessionPinType.Main;
     this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
   }
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    const reusePreflightStatus =
+      isProtocolV2 && this.protocolV2UnlockContext?.preflightStatusRefreshed === true;
+    let state = reusePreflightStatus
+      ? await this.device.getDeviceState()
+      : await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
     const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
       candidate.status.unlocked === true &&
@@ -115,14 +129,25 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       currentDeviceId = state.identity.deviceId;
       return state;
     };
+    const resolveProtocolV2DeviceStateAfterSession = async (session: unknown) => {
+      if (!wasWalletStatusRefreshed(session)) {
+        return refreshProtocolV2DeviceState();
+      }
+      state = await this.device.getDeviceState();
+      currentDeviceId = state.identity.deviceId;
+      return state;
+    };
     const ensureProtocolV2WalletStatus = async () => {
       if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
-        await this.device.unlockDevice(DeviceSessionPinType.Main, {
-          source: 'unlock-coordinator',
-          reason: 'device-locked',
-          deviceOnly: true,
-          method: 'openWalletSession',
-        });
+        await this.device.unlockDevice(
+          this.protocolV2PreUnlockPinType ?? DeviceSessionPinType.Main,
+          {
+            source: 'unlock-coordinator',
+            reason: 'device-locked',
+            deviceOnly: true,
+            method: 'openWalletSession',
+          }
+        );
         requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
       }
       return state;
@@ -135,17 +160,19 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             onlyMainPin: true,
-            deriveCardano: this.payload.deriveCardano,
             selectMainWalletBeforeRestore:
               !hasAuthoritativeProtocolV2WalletStatus(state) ||
               state.status.unlockedAttachPin === true,
+            mainPinSelected: this.protocolV2UnlockContext?.preflightMainPinSelected,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
       const refreshedState = isProtocolV2
-        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        ? requireAuthoritativeProtocolV2WalletStatus(
+            await resolveProtocolV2DeviceStateAfterSession(session)
+          )
         : state;
       const deviceId = requireDeviceId();
       if (
@@ -197,7 +224,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             expectedPassphraseState: this.params.passphraseState,
-            deriveCardano: this.payload.deriveCardano,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             expectPassphraseState: this.params.passphraseState,
@@ -229,11 +255,12 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
           ...(readCurrentAttachPinSession
             ? { readCurrentAttachPinSession: true }
             : { forceWalletSelection: true }),
-          deriveCardano: this.payload.deriveCardano,
         })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
     const refreshedState = isProtocolV2
-      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      ? requireAuthoritativeProtocolV2WalletStatus(
+          await resolveProtocolV2DeviceStateAfterSession(session)
+        )
       : state;
     const deviceId = requireDeviceId();
     if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -393,14 +393,17 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
           // the root fingerprint, so each nested chain method must resume the
           // requested standard or hidden wallet before sending its device command.
           const useEmptyPassphrase = this.payload.useEmptyPassphrase === true;
-          const deriveCardano = method.name.startsWith('cardano');
+          // Nested Cardano methods opt in to [Standard, Cardano] if Ask rebuilds.
+          // Other chains stay Standard-only.
+          const deriveCardano = method.name.startsWith('cardano') ? true : undefined;
           const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
           if (this.device.isProtocolV2() && shouldResumeWalletSession) {
             const passphraseStateSafety = await this.device.checkPassphraseStateSafety(
               this.payload.passphraseState,
               useEmptyPassphrase,
               this.payload.skipPassphraseCheck,
-              deriveCardano
+              deriveCardano,
+              this.protocolV2UnlockContext?.preflightMainPinSelected
             );
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);

package/src/api/evm/EVMSignTypedData.ts

@@ -360,6 +360,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     const supportBiggerData =
       DeviceModelToTypes.model_classic1s.includes(currentDeviceType) ||
+      DeviceModelToTypes.model_pro2.includes(currentDeviceType) ||
       (DeviceModelToTypes.model_touch.includes(currentDeviceType) &&
         semver.gte(currentVersion, supportBiggerDataVersion));
 

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -41,9 +41,15 @@ const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
  */
 export const BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS = 5000;
 
-type FirmwareTransferMetrics = Pick<
+type FirmwareProgressMetadata = Pick<
   FirmwareProgress['payload'],
-  'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
+  | 'transferredBytes'
+  | 'totalBytes'
+  | 'rateBytesPerSecond'
+  | 'elapsedMs'
+  | 'installTargetId'
+  | 'installPhase'
+  | 'installPhaseProgress'
 >;
 
 const isDeviceDisconnectedError = (error: unknown) => {
@@ -103,7 +109,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   postProgressMessage = (
     progress: number,
     progressType: IFirmwareUpdateProgressType,
-    metrics?: FirmwareTransferMetrics
+    metrics?: FirmwareProgressMetadata
   ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {

package/src/api/helpers/protocolV2FileWrite.ts

@@ -36,6 +36,8 @@ export type ProtocolV2FileWriteOptions = {
   chunkSize?: number;
   chunkLen?: number;
   chunkSizeLimit?: number;
+  /** BLE-only limit for a caller whose fixed short path has a verified larger frame budget. */
+  bleChunkSizeLimit?: number;
   overwrite?: boolean;
   append?: boolean;
   uiPercentage?: number;
@@ -114,11 +116,15 @@ export function isProtocolV2ResponseTimeout(error: unknown) {
   );
 }
 
-function getProtocolV2FileChunkLimit() {
+function getProtocolV2FileChunkLimit(bleChunkSizeLimit?: number) {
   const env = DataManager.getSettings('env');
-  return env && DataManager.isBleConnect(env)
-    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+  if (env && DataManager.isBleConnect(env)) {
+    const configuredLimit = Number(bleChunkSizeLimit);
+    return Number.isFinite(configuredLimit) && configuredLimit > 0
+      ? Math.floor(configuredLimit)
+      : PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+  }
+  return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
 }
 
 async function dataToUint8Array(data: ProtocolV2FileWriteData): Promise<Uint8Array> {
@@ -178,7 +184,7 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
     );
   }
 
-  const defaultChunkSizeLimit = getProtocolV2FileChunkLimit();
+  const defaultChunkSizeLimit = getProtocolV2FileChunkLimit(options.bleChunkSizeLimit);
   const configuredChunkSizeLimit = Number(options.chunkSizeLimit);
   const chunkSizeLimit =
     Number.isFinite(configuredChunkSizeLimit) && configuredChunkSizeLimit > 0

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

@@ -4,7 +4,13 @@ import { invalidParameter } from '../helpers/filesystemValidation';
 import type { DeviceFirmwareUpdateStatusGetParams } from './helpers';
 import type { DeviceFirmwareUpdateRecordFields } from '@onekeyfe/hd-transport';
 
-const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = ['status', 'payload_version', 'path'] as const;
+const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = [
+  'status',
+  'progress_percent',
+  'phase_info',
+  'payload_version',
+  'path',
+] as const;
 
 function normalizeStatusFields(
   fields: DeviceFirmwareUpdateStatusGetParams['fields']

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

@@ -20,6 +20,10 @@ import {
   getCompletePro2NftBasenames,
 } from '../../utils/pro2Nft';
 import { encodePro2Image } from '../../utils/pro2Wallpaper';
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../../utils/pro2HostAssetPackage';
 import { BaseMethod } from '../BaseMethod';
 import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
@@ -38,8 +42,11 @@ export type DeviceUploadNftParams = {
 
 export type DeviceUploadNftResponse = {
   basename: string;
+  /** Final image path after firmware extracts a host-asset package. */
   imagePath: string;
+  /** Final thumbnail path after firmware extracts a host-asset package. */
   thumbnailPath: string;
+  /** Final metadata path after firmware extracts a host-asset package. */
   metadataPath: string;
   totalSize: number;
   nftUpdated: true;
@@ -138,7 +145,7 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     this.useDevicePassphraseState = false;
   }
 
-  private async assertCapabilities() {
+  private async assertCapabilities(useHostAssetPackage: boolean) {
     const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
     const hasFileWrite = supportsProtocolV2Message(
       protocolInfo,
@@ -150,7 +157,7 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     );
     const hasDirList = supportsProtocolV2Message(protocolInfo, FILESYSTEM_DIR_LIST_MESSAGE_TYPE);
     const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
-    if (!hasFileWrite || !hasPathInfo || !hasDirList || !hasNftUpdate) {
+    if (!hasFileWrite || !hasNftUpdate || (!useHostAssetPackage && (!hasPathInfo || !hasDirList))) {
       throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
     }
   }
@@ -192,16 +199,32 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     const { bundle } = this;
     if (!bundle) throw invalidParameter('NFT data has not been initialized.');
 
-    await this.assertCapabilities();
+    const useHostAssetPackage = supportsPro2HostAssetPackage(
+      this.device.state?.versions.firmware ?? undefined
+    );
+    await this.assertCapabilities(useHostAssetPackage);
     this.throwIfAborted();
-    await this.assertStorageCapacity(bundle.basename);
+    if (!useHostAssetPackage) await this.assertStorageCapacity(bundle.basename);
     this.throwIfAborted();
 
-    const files = [
+    const extractedFiles = [
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
     ];
+    const files = useHostAssetPackage
+      ? [
+          {
+            path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.okpkg`,
+            data: buildPro2HostAssetPackage(
+              extractedFiles.map(file => ({
+                name: file.path.slice(`${PRO2_NFT_DIRECTORY}/`.length),
+                data: file.data,
+              }))
+            ),
+          },
+        ]
+      : extractedFiles;
     const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
     let transferredBeforeFile = 0;
 
@@ -238,9 +261,9 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     const response = await this.updateNft(bundle.basename);
     return {
       basename: bundle.basename,
-      imagePath: files[0].path,
-      thumbnailPath: files[1].path,
-      metadataPath: files[2].path,
+      imagePath: extractedFiles[0].path,
+      thumbnailPath: extractedFiles[1].path,
+      metadataPath: extractedFiles[2].path,
       totalSize,
       nftUpdated: true,
       message: response.message?.message,

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

@@ -16,14 +16,26 @@ import {
   type Pro2WallpaperColorFormat,
   encodePro2Wallpaper,
 } from '../../utils/pro2Wallpaper';
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../../utils/pro2HostAssetPackage';
 
 export type DeviceUploadWallpaperParams = {
   jpegBase64: string;
+  /**
+   * Legacy firmware uses this name for the uploaded `.bin` file. Firmware
+   * 1.0.1+ always consumes the fixed `wallpaper.okpkg` package path.
+   */
   fileName?: string;
   chunkSize?: number;
 };
 
 export type DeviceUploadWallpaperResponse = {
+  /**
+   * Filesystem path sent to `DeviceSettingsSet`. On firmware 1.0.1+ this is
+   * the temporary package path; firmware extracts and persists wallpaper.bin.
+   */
   path: string;
   size: number;
   colorFormat: Pro2WallpaperColorFormat;
@@ -31,10 +43,13 @@ export type DeviceUploadWallpaperResponse = {
 };
 
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
+const WALLPAPER_PACKAGE_PATH = `${WALLPAPER_DIRECTORY}/wallpaper.okpkg`;
+const WALLPAPER_PACKAGE_ENTRY = 'wallpaper.bin';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
 const FILESYSTEM_DIR_MAKE_MESSAGE_TYPE = 60809;
+const WALLPAPER_PACKAGE_BLE_CHUNK_SIZE = 1960;
 const Log = getLogger(LoggerNames.Method);
 
 function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
@@ -116,17 +131,16 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.directoryReady = true;
   }
 
-  private async upload() {
+  private async upload(path: string, data: Uint8Array, bleChunkSizeLimit?: number) {
     if (this.uploaded) return;
-    const { encoded } = this;
-    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
 
     await writeProtocolV2File({
       commands: this.device.commands,
-      path: this.path,
-      data: encoded.data,
-      totalSize: encoded.data.byteLength,
+      path,
+      data,
+      totalSize: data.byteLength,
       chunkSize: this.params.chunkSize,
+      bleChunkSizeLimit,
       maxChunkRetries: 3,
       overwrite: true,
       append: false,
@@ -145,7 +159,18 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
     await this.assertCapabilities();
     await this.ensureDirectory();
-    await this.upload();
+    const useHostAssetPackage = supportsPro2HostAssetPackage(
+      this.device.state?.versions.firmware ?? undefined
+    );
+    const data = useHostAssetPackage
+      ? buildPro2HostAssetPackage([{ name: WALLPAPER_PACKAGE_ENTRY, data: encoded.data }])
+      : encoded.data;
+    if (useHostAssetPackage) this.path = WALLPAPER_PACKAGE_PATH;
+    await this.upload(
+      this.path,
+      data,
+      useHostAssetPackage ? WALLPAPER_PACKAGE_BLE_CHUNK_SIZE : undefined
+    );
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: this.path },
     });
@@ -160,7 +185,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     }
     return {
       path: this.path,
-      size: encoded.data.byteLength,
+      size: data.byteLength,
       colorFormat: encoded.colorFormat,
       message: response.message?.message,
     };

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

@@ -1,4 +1,5 @@
 import { DeviceRebootType } from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { invalidParameter, validateNonEmptyString } from '../helpers/filesystemValidation';
 import { ProtocolV2FirmwareTargetType } from '../../protocols/protocol-v2/firmware';
@@ -103,6 +104,13 @@ export const getProtocolV2UnknownErrorText = (error: unknown) => {
 };
 
 export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
+  const errorCode =
+    error && typeof error === 'object'
+      ? (error as { errorCode?: number; code?: number }).errorCode ??
+        (error as { errorCode?: number; code?: number }).code
+      : undefined;
+  if (errorCode === HardwareErrorCode.BleDeviceDisconnected) return true;
+
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();
   const compactMessage = message.replace(/\s+/g, '');
   return (

package/src/core/RequestQueue.ts

@@ -56,11 +56,20 @@ export default class RequestQueue {
     return false;
   }
 
+  private isRequestForConnectId(request: RequestTask, connectId: string) {
+    const { method } = request;
+    return (
+      method.connectId === connectId ||
+      method.device?.mainId === connectId ||
+      method.device?.getConnectId() === connectId
+    );
+  }
+
   // 取消与指定connectId相关的所有请求
   public abortRequestsByConnectId(connectId: string) {
     let count = 0;
     this.requestQueue.forEach((request, _) => {
-      if (request.abortController && request.method.connectId === connectId) {
+      if (request.abortController && this.isRequestForConnectId(request, connectId)) {
         request.abortController.abort();
         request.abortController = undefined;
         count++;
@@ -69,6 +78,12 @@ export default class RequestQueue {
     return count;
   }
 
+  public getRequestTasksIdByConnectId(connectId: string) {
+    return Array.from(this.requestQueue.values())
+      .filter(request => this.isRequestForConnectId(request, connectId))
+      .map(request => request.id);
+  }
+
   // 取消所有请求
   public abortAllRequests() {
     let count = 0;