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

package/src/api/OpenWalletSession.ts

@@ -29,12 +29,6 @@ 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(
@@ -93,20 +87,12 @@ 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();
-    const reusePreflightStatus =
-      isProtocolV2 && this.protocolV2UnlockContext?.preflightStatusRefreshed === true;
-    let state = reusePreflightStatus
-      ? await this.device.getDeviceState()
-      : await this.device.getDeviceState({ refreshSections: ['status'] });
+    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
     const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
       candidate.status.unlocked === true &&
@@ -129,25 +115,14 @@ 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(
-          this.protocolV2PreUnlockPinType ?? DeviceSessionPinType.Main,
-          {
-            source: 'unlock-coordinator',
-            reason: 'device-locked',
-            deviceOnly: true,
-            method: 'openWalletSession',
-          }
-        );
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'openWalletSession',
+        });
         requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
       }
       return state;
@@ -164,16 +139,13 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
             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 resolveProtocolV2DeviceStateAfterSession(session)
-          )
+        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
         : state;
       const deviceId = requireDeviceId();
       if (
@@ -261,9 +233,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
         })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
     const refreshedState = isProtocolV2
-      ? requireAuthoritativeProtocolV2WalletStatus(
-          await resolveProtocolV2DeviceStateAfterSession(session)
-        )
+      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
       : state;
     const deviceId = requireDeviceId();
     if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -400,8 +400,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
               this.payload.passphraseState,
               useEmptyPassphrase,
               this.payload.skipPassphraseCheck,
-              deriveCardano,
-              this.protocolV2UnlockContext?.preflightMainPinSelected
+              deriveCardano
             );
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);

package/src/api/evm/EVMSignTypedData.ts

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

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

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

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

@@ -20,10 +20,6 @@ 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';
@@ -142,7 +138,7 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     this.useDevicePassphraseState = false;
   }
 
-  private async assertCapabilities(useHostAssetPackage: boolean) {
+  private async assertCapabilities() {
     const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
     const hasFileWrite = supportsProtocolV2Message(
       protocolInfo,
@@ -154,7 +150,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 || !hasNftUpdate || (!useHostAssetPackage && (!hasPathInfo || !hasDirList))) {
+    if (!hasFileWrite || !hasPathInfo || !hasDirList || !hasNftUpdate) {
       throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
     }
   }
@@ -196,32 +192,16 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     const { bundle } = this;
     if (!bundle) throw invalidParameter('NFT data has not been initialized.');
 
-    const useHostAssetPackage = supportsPro2HostAssetPackage(
-      this.device.getCurrentFirmwareVersionString()
-    );
-    await this.assertCapabilities(useHostAssetPackage);
+    await this.assertCapabilities();
     this.throwIfAborted();
-    if (!useHostAssetPackage) await this.assertStorageCapacity(bundle.basename);
+    await this.assertStorageCapacity(bundle.basename);
     this.throwIfAborted();
 
-    const extractedFiles = [
+    const files = [
       { 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;
 
@@ -258,9 +238,9 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     const response = await this.updateNft(bundle.basename);
     return {
       basename: bundle.basename,
-      imagePath: extractedFiles[0].path,
-      thumbnailPath: extractedFiles[1].path,
-      metadataPath: extractedFiles[2].path,
+      imagePath: files[0].path,
+      thumbnailPath: files[1].path,
+      metadataPath: files[2].path,
       totalSize,
       nftUpdated: true,
       message: response.message?.message,

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

@@ -16,10 +16,6 @@ import {
   type Pro2WallpaperColorFormat,
   encodePro2Wallpaper,
 } from '../../utils/pro2Wallpaper';
-import {
-  buildPro2HostAssetPackage,
-  supportsPro2HostAssetPackage,
-} from '../../utils/pro2HostAssetPackage';
 
 export type DeviceUploadWallpaperParams = {
   jpegBase64: string;
@@ -35,8 +31,6 @@ 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;
@@ -122,14 +116,16 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.directoryReady = true;
   }
 
-  private async upload(path: string, data: Uint8Array) {
+  private async upload() {
     if (this.uploaded) return;
+    const { encoded } = this;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
 
     await writeProtocolV2File({
       commands: this.device.commands,
-      path,
-      data,
-      totalSize: data.byteLength,
+      path: this.path,
+      data: encoded.data,
+      totalSize: encoded.data.byteLength,
       chunkSize: this.params.chunkSize,
       maxChunkRetries: 3,
       overwrite: true,
@@ -149,14 +145,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
     await this.assertCapabilities();
     await this.ensureDirectory();
-    const useHostAssetPackage = supportsPro2HostAssetPackage(
-      this.device.getCurrentFirmwareVersionString()
-    );
-    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);
+    await this.upload();
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: this.path },
     });
@@ -171,7 +160,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     }
     return {
       path: this.path,
-      size: data.byteLength,
+      size: encoded.data.byteLength,
       colorFormat: encoded.colorFormat,
       message: response.message?.message,
     };

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

@@ -1,5 +1,4 @@
 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';
@@ -104,13 +103,6 @@ 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/index.ts

@@ -415,13 +415,6 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
-    // This early return bypasses the normal-path bookkeeping at the end of the
-    // call. Without it the task leaks and haunts every later queue snapshot
-    // and cancel sweep (field log: a completed task lingered for 6 minutes),
-    // and the request stays in the active maps, so repeated preconnects pile
-    // up phantom work in diagnostics.
-    completeMethodRequestContext(method);
-    requestQueue.releaseTask(method.responseID);
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -651,8 +644,7 @@ const onCallDevice = async (
                 method.payload?.passphraseState,
                 method.payload?.useEmptyPassphrase,
                 method.payload?.skipPassphraseCheck,
-                hasDeriveCardano(method),
-                method.protocolV2UnlockContext?.preflightMainPinSelected
+                hasDeriveCardano(method)
               );
 
               // Double check, handles the special case of Touch/Pro
@@ -958,72 +950,11 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
-export function isProtocolV2PeerRemovedPairingError(method: BaseMethod, error: unknown) {
-  return (
-    method.payload.connectProtocol === 'V2' &&
-    (error as { errorCode?: unknown })?.errorCode ===
-      HardwareErrorCode.BlePeerRemovedPairingInformation
-  );
-}
-
 /**
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
  */
-// device.acquire awaits a transport reply with no deadline of its own; a
-// transport that never settles (field case: Electron main lost an IPC reply,
-// "reply was never sent" after 5 minutes) hangs the call forever and cancel()
-// only takes effect at poll checkpoints. Race acquire against a deadline and
-// the caller's abort signal so the hang is bounded and cancel is immediate.
-const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
-
-function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    let settled = false;
-    const settle = (fn: () => void) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(deadline);
-      abortSignal?.removeEventListener('abort', onAbort);
-      fn();
-    };
-    const onAbort = () =>
-      settle(() => reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)));
-    const deadline = setTimeout(
-      () =>
-        settle(() =>
-          reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.BleTimeoutError,
-              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
-            )
-          )
-        ),
-      BLE_ACQUIRE_DEADLINE_MS
-    );
-    // Attach before any early return so a late settlement of acquirePromise
-    // is always consumed — an abort or deadline must never leave the acquire
-    // rejection unhandled.
-    acquirePromise.then(
-      value => settle(() => resolve(value)),
-      error => settle(() => reject(error))
-    );
-    if (abortSignal) {
-      if (abortSignal.aborted) {
-        onAbort();
-        return;
-      }
-      abortSignal.addEventListener('abort', onAbort);
-    }
-  });
-}
-
-async function connectDeviceForBle(
-  method: BaseMethod,
-  device: Device,
-  abortSignal?: AbortSignal,
-  retryCount = 0
-) {
+async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
     if (device.wasInterruptedByUser()) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
@@ -1037,43 +968,9 @@ async function connectDeviceForBle(
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
-      // The deadline/abort guards are scoped to the desktop electron
-      // transport: its IPC acquire is the only path with a proven
-      // never-settling failure mode, while react-native/lowlevel acquire may
-      // legitimately block on a user-driven system bonding prompt for longer
-      // than any sane deadline. Other envs keep the plain acquire unchanged.
-      const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
-      // A cancel landing during the retry backoff must not start a new acquire.
-      if (useAcquireGuards && abortSignal?.aborted) {
-        throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
-      }
-      if (!useAcquireGuards) {
-        await device.acquire(method.payload.connectProtocol, {
-          forceProtocolDetection: method.payload.forceProtocolDetection,
-        });
-      } else {
-        try {
-          await raceBleAcquire(
-            device.acquire(method.payload.connectProtocol, {
-              forceProtocolDetection: method.payload.forceProtocolDetection,
-            }),
-            abortSignal
-          );
-        } catch (err) {
-          // A deadline hit means the transport is wedged mid-acquire; drop the
-          // link before the retry so it cold-connects instead of stacking a
-          // second connect onto the half-open one.
-          if (
-            err.errorCode === HardwareErrorCode.BleTimeoutError &&
-            device.mainId &&
-            device.deviceConnector
-          ) {
-            await device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
-            device.markTransportDisconnected();
-          }
-          throw err;
-        }
-      }
+      await device.acquire(method.payload.connectProtocol, {
+        forceProtocolDetection: method.payload.forceProtocolDetection,
+      });
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1113,7 +1010,7 @@ async function connectDeviceForBle(
       const nextRetry = retryCount + 1;
       Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, abortSignal, nextRetry);
+      await connectDeviceForBle(method, device, nextRetry);
     } else {
       throw err;
     }
@@ -1223,7 +1120,7 @@ const ensureConnected = async (
             if (tryCount === 1) {
               device.beginConnectionAttempt();
             }
-            await connectDeviceForBle(method, device, abortSignal);
+            await connectDeviceForBle(method, device);
           }
           resolve(device);
           return;
@@ -1267,8 +1164,7 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
-          ].includes(error.errorCode) ||
-          isProtocolV2PeerRemovedPairingError(method, error)
+          ].includes(error.errorCode)
         ) {
           reject(error);
           return;
@@ -1324,9 +1220,6 @@ export const cancel = (context: CoreContext, connectId?: string) => {
           ','
         )}`
       );
-      // Abort before rejecting: rejectRequest releases the task and would make
-      // its AbortController unreachable to an in-flight method loop.
-      requestQueue.abortRequestsByConnectId(connectId);
       const canceledDevices: Device[] = [];
       const interruptDevice = (device: Device | undefined, deviceConnectId: string) => {
         if (!device || canceledDevices.includes(device)) {
@@ -1351,6 +1244,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
         }
       }
       interruptDevice(deviceCacheMap.get(connectId), connectId);
+      requestQueue.abortRequestsByConnectId(connectId);
       pollingManager.stop(connectId);
     } catch (e) {
       Log.error('Cancel API Error: ', e);
@@ -1359,8 +1253,6 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {
       Log.debug('Cancel Api all _deviceList: ');
-      // Keep method abort signals observable until every active task is rejected.
-      requestQueue.abortAllRequests();
       const canceledDevices: Device[] = [];
       const interruptDevice = (device?: Device) => {
         if (!device || canceledDevices.includes(device)) {
@@ -1385,6 +1277,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
         }
       }
       deviceCacheMap.forEach(interruptDevice);
+      requestQueue.abortAllRequests();
       pollingManager.stopAll();
     } else {
       _deviceList?.allDevices().forEach(device => {
@@ -1435,10 +1328,6 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
 const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
   if (!method.useDevicePassphraseState) return false;
 
-  if (device.isProtocolV2() && method.payload?.useEmptyPassphrase === true) {
-    return true;
-  }
-
   return device.hasUsePassphrase();
 };