@onekeyfe/hd-core 1.2.0-alpha.36 → 1.2.0-alpha.39

package/src/types/api/protocolV2.ts

@@ -5,6 +5,10 @@ import type {
   DeviceUploadWallpaperParams,
   DeviceUploadWallpaperResponse,
 } from '../../api/protocol-v2/DeviceUploadWallpaper';
+import type {
+  DeviceUploadNftParams,
+  DeviceUploadNftResponse,
+} from '../../api/protocol-v2/DeviceUploadNft';
 
 // Re-export implementation parameter types as the single source of truth.
 export type { DeviceRebootParams, RebootTypeInput } from '../../api/protocol-v2/helpers';
@@ -12,6 +16,10 @@ export type {
   DeviceUploadWallpaperParams,
   DeviceUploadWallpaperResponse,
 } from '../../api/protocol-v2/DeviceUploadWallpaper';
+export type {
+  DeviceUploadNftParams,
+  DeviceUploadNftResponse,
+} from '../../api/protocol-v2/DeviceUploadNft';
 
 // ── Shared response shapes (Protocol V2 file system) ────────────────────
 
@@ -52,6 +60,11 @@ export declare function deviceUploadWallpaper(
   params: CommonParams & DeviceUploadWallpaperParams
 ): Response<DeviceUploadWallpaperResponse>;
 
+export declare function deviceUploadNft(
+  connectId: string,
+  params: CommonParams & DeviceUploadNftParams
+): Response<DeviceUploadNftResponse>;
+
 export declare function uploadPortfolio(
   connectId: string,
   params: {

package/src/utils/homescreen.ts

@@ -4,6 +4,12 @@ import { EDeviceType } from '@onekeyfe/hd-shared';
 import { getDeviceType } from './deviceInfoUtils';
 import { getDeviceFirmwareVersion } from './deviceVersionUtils';
 import { PRO2_WALLPAPER_HEIGHT, PRO2_WALLPAPER_WIDTH } from './pro2Wallpaper';
+import {
+  PRO2_NFT_IMAGE_HEIGHT,
+  PRO2_NFT_IMAGE_WIDTH,
+  PRO2_NFT_THUMBNAIL_HEIGHT,
+  PRO2_NFT_THUMBNAIL_WIDTH,
+} from './pro2Nft';
 
 import type { Features, IDeviceType } from '../types';
 
@@ -302,6 +308,31 @@ type SizeConfig = {
   radius?: number;
 };
 
+export const getNftSize = ({
+  deviceType,
+  thumbnail,
+}: {
+  deviceType: IDeviceType;
+  thumbnail?: boolean;
+}): SizeConfig | undefined => {
+  const sizes: Partial<Record<IDeviceType, { full: SizeConfig; thumbnail: SizeConfig }>> = {
+    touch: {
+      full: { width: 480, height: 800 },
+      thumbnail: { width: 238, height: 238 },
+    },
+    pro: {
+      full: { width: 480, height: 800 },
+      thumbnail: { width: 226, height: 226, radius: 40 },
+    },
+    pro2: {
+      full: { width: PRO2_NFT_IMAGE_WIDTH, height: PRO2_NFT_IMAGE_HEIGHT },
+      thumbnail: { width: PRO2_NFT_THUMBNAIL_WIDTH, height: PRO2_NFT_THUMBNAIL_HEIGHT },
+    },
+  };
+
+  return sizes[deviceType]?.[thumbnail ? 'thumbnail' : 'full'];
+};
+
 export const getHomeScreenSize = ({
   deviceType,
   homeScreenType,
@@ -312,12 +343,7 @@ export const getHomeScreenSize = ({
   thumbnail?: boolean;
 }) => {
   if (deviceType === EDeviceType.Pro2) {
-    return thumbnail
-      ? undefined
-      : {
-          width: PRO2_WALLPAPER_WIDTH,
-          height: PRO2_WALLPAPER_HEIGHT,
-        };
+    return thumbnail ? undefined : { width: PRO2_WALLPAPER_WIDTH, height: PRO2_WALLPAPER_HEIGHT };
   }
 
   const sizes: Partial<

package/src/utils/index.ts

@@ -54,7 +54,12 @@ export { getHDPath, getScriptType, getOutputScriptType } from '../api/helpers/pa
 
 export const isBleConnect = (env: string) => env === 'react-native' || env === 'lowlevel';
 
-export { getHomeScreenHex, getHomeScreenDefaultList, getHomeScreenSize } from './homescreen';
+export {
+  getHomeScreenHex,
+  getHomeScreenDefaultList,
+  getHomeScreenSize,
+  getNftSize,
+} from './homescreen';
 export { encodePro2Wallpaper, PRO2_WALLPAPER_HEIGHT, PRO2_WALLPAPER_WIDTH } from './pro2Wallpaper';
 export type { Pro2WallpaperColorFormat } from './pro2Wallpaper';
 

package/src/utils/pro2Nft.ts

@@ -0,0 +1,91 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { invalidParameter } from '../api/helpers/filesystemValidation';
+import { encodePro2Image } from './pro2Wallpaper';
+
+export const PRO2_NFT_IMAGE_WIDTH = 540;
+export const PRO2_NFT_IMAGE_HEIGHT = 540;
+export const PRO2_NFT_THUMBNAIL_WIDTH = 263;
+export const PRO2_NFT_THUMBNAIL_HEIGHT = 263;
+export const PRO2_NFT_DIRECTORY = 'vol1:/nft';
+export const PRO2_NFT_DEFAULT_CHUNK_SIZE = 512;
+export const PRO2_NFT_DEFAULT_PACE_MS = 20;
+export const PRO2_NFT_DEFAULT_TIMEOUT_MS = 15_000;
+export const PRO2_NFT_MIN_CHUNK_SIZE = 64;
+export const PRO2_NFT_MAX_CHUNK_SIZE = 2048;
+
+export type Pro2NftImage = {
+  width: number;
+  height: number;
+  rgba: Uint8Array | ArrayBuffer;
+};
+
+export type Pro2NftBundle = {
+  basename: string;
+  image: Uint8Array;
+  thumbnail: Uint8Array;
+  metadata: Uint8Array;
+};
+
+function utf8Length(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function assertImage(
+  name: string,
+  image: Pro2NftImage,
+  expectedWidth: number,
+  expectedHeight: number
+) {
+  if (image.width !== expectedWidth || image.height !== expectedHeight) {
+    throw invalidParameter(
+      `Pro2 NFT ${name} dimensions must be ${expectedWidth}x${expectedHeight}.`
+    );
+  }
+  if (!(image.rgba instanceof ArrayBuffer) && !ArrayBuffer.isView(image.rgba)) {
+    throw invalidParameter(`Parameter [${name}.rgba] must be an ArrayBuffer or Uint8Array.`);
+  }
+}
+
+export function buildPro2NftBundle(options: {
+  image: Pro2NftImage;
+  thumbnail: Pro2NftImage;
+  title: string;
+  subtitle: string;
+  timestampMs: number;
+}): Pro2NftBundle {
+  const { image, thumbnail, title, subtitle, timestampMs } = options;
+  assertImage('image', image, PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT);
+  assertImage('thumbnail', thumbnail, PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT);
+  const titleLength = typeof title === 'string' ? utf8Length(title) : 0;
+  const subtitleLength =
+    typeof subtitle === 'string' ? utf8Length(subtitle) : Number.POSITIVE_INFINITY;
+  if (titleLength < 1 || titleLength > 63) {
+    throw invalidParameter('Pro2 NFT title must contain 1 to 63 UTF-8 bytes.');
+  }
+  if (subtitleLength > 95) {
+    throw invalidParameter('Pro2 NFT subtitle must contain at most 95 UTF-8 bytes.');
+  }
+  if (!Number.isSafeInteger(timestampMs) || timestampMs <= 0) {
+    throw invalidParameter('Parameter [timestampMs] must be a positive safe integer.');
+  }
+
+  const encodedImage = encodePro2Image({ ...image, alphaMode: 'black-background' }).data;
+  const encodedThumbnail = encodePro2Image({
+    ...thumbnail,
+    alphaMode: 'black-background',
+  }).data;
+  const metadata = new TextEncoder().encode(JSON.stringify({ title, subtitle }));
+  if (metadata.byteLength === 0 || metadata.byteLength > 512) {
+    throw invalidParameter('Pro2 NFT metadata must contain 1 to 512 UTF-8 bytes.');
+  }
+
+  const hash8 = bytesToHex(blake2s(encodedImage)).slice(0, 8);
+  return {
+    basename: `nft-${hash8}-${timestampMs}`,
+    image: encodedImage,
+    thumbnail: encodedThumbnail,
+    metadata,
+  };
+}

package/src/utils/pro2Wallpaper.ts

@@ -8,6 +8,8 @@ export const PRO2_WALLPAPER_HEIGHT = 1024;
 
 export type Pro2WallpaperColorFormat = 'RGB565' | 'RGB565A8';
 
+export type Pro2ImageAlphaMode = 'preserve' | 'black-background';
+
 const COLOR_FORMAT_RGB565 = 0x12;
 const COLOR_FORMAT_RGB565A8 = 0x14;
 
@@ -36,10 +38,11 @@ function align(value: number, boundary: number): number {
   return Math.ceil(value / boundary) * boundary;
 }
 
-export function encodePro2Wallpaper(options: {
+export function encodePro2Image(options: {
   width: number;
   height: number;
   rgba: Uint8Array | ArrayBuffer;
+  alphaMode?: Pro2ImageAlphaMode;
 }): { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat } {
   const { width, height } = options;
   if (!Number.isInteger(width) || width <= 0 || width > 0xffff) {
@@ -57,11 +60,14 @@ export function encodePro2Wallpaper(options: {
     );
   }
 
+  const alphaMode = options.alphaMode ?? 'preserve';
   let hasTransparency = false;
-  for (let index = 3; index < rgba.length; index += 4) {
-    if (rgba[index] !== 0xff) {
-      hasTransparency = true;
-      break;
+  if (alphaMode === 'preserve') {
+    for (let index = 3; index < rgba.length; index += 4) {
+      if (rgba[index] !== 0xff) {
+        hasTransparency = true;
+        break;
+      }
     }
   }
 
@@ -85,9 +91,22 @@ 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);
-      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 alpha = rgba[sourceOffset + 3];
+      const redChannel =
+        alphaMode === 'black-background'
+          ? Math.round((rgba[sourceOffset] * alpha) / 0xff)
+          : rgba[sourceOffset];
+      const greenChannel =
+        alphaMode === 'black-background'
+          ? Math.round((rgba[sourceOffset + 1] * alpha) / 0xff)
+          : rgba[sourceOffset + 1];
+      const blueChannel =
+        alphaMode === 'black-background'
+          ? Math.round((rgba[sourceOffset + 2] * alpha) / 0xff)
+          : rgba[sourceOffset + 2];
+      const red = Math.min(redChannel + RED_THRESHOLD[thresholdIndex], 0xff) & 0xf8;
+      const green = Math.min(greenChannel + GREEN_THRESHOLD[thresholdIndex], 0xff) & 0xfc;
+      const blue = Math.min(blueChannel + 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;
@@ -101,3 +120,11 @@ export function encodePro2Wallpaper(options: {
 
   return { data, colorFormat };
 }
+
+export function encodePro2Wallpaper(options: {
+  width: number;
+  height: number;
+  rgba: Uint8Array | ArrayBuffer;
+}): { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat } {
+  return encodePro2Image(options);
+}

package/src/utils/uiProgressThrottle.ts

@@ -0,0 +1,63 @@
+import { UI_EVENT, UI_REQUEST } from '../events/ui-request';
+
+import type { CoreMessage } from '../events';
+
+const DEFAULT_UI_PROGRESS_INTERVAL_MS = 250;
+
+type UiProgressThrottleState = {
+  lastEmittedAt: number;
+  lastProgress?: number;
+};
+
+const normalizeProgress = (progress: unknown) => {
+  if (typeof progress !== 'number' || !Number.isFinite(progress)) {
+    return undefined;
+  }
+
+  return Math.max(0, Math.min(100, Math.floor(progress)));
+};
+
+export const createUiProgressMessageFilter = (
+  intervalMs = DEFAULT_UI_PROGRESS_INTERVAL_MS,
+  now = Date.now
+) => {
+  const stateByType = new Map<string, UiProgressThrottleState>();
+
+  return (message: CoreMessage) => {
+    if (
+      !('event' in message) ||
+      message.event !== UI_EVENT ||
+      (message.type !== UI_REQUEST.DEVICE_PROGRESS && message.type !== UI_REQUEST.FIRMWARE_PROGRESS)
+    ) {
+      return true;
+    }
+
+    const key =
+      message.type === UI_REQUEST.FIRMWARE_PROGRESS
+        ? `${message.type}:${message.payload.progressType}`
+        : message.type;
+    const progress = normalizeProgress(message.payload.progress);
+    const currentTime = now();
+    const state = stateByType.get(key);
+
+    if (!state) {
+      stateByType.set(key, { lastEmittedAt: currentTime, lastProgress: progress });
+      return true;
+    }
+
+    const isBoundary = progress === 0 || progress === 100;
+    if (isBoundary && progress === state.lastProgress) {
+      return false;
+    }
+
+    const startsNewPhase =
+      progress !== undefined && state.lastProgress !== undefined && progress < state.lastProgress;
+
+    if (!isBoundary && !startsNewPhase && currentTime - state.lastEmittedAt < intervalMs) {
+      return false;
+    }
+
+    stateByType.set(key, { lastEmittedAt: currentTime, lastProgress: progress });
+    return true;
+  };
+};

package/dist/api/firmware/progressThrottle.d.ts

@@ -1,3 +0,0 @@
-import type { IFirmwareUpdateProgressType } from '../../events/ui-request';
-export declare const createFirmwareProgressThrottle: (intervalMs?: number) => (progress: number, progressType: IFirmwareUpdateProgressType) => boolean;
-//# sourceMappingURL=progressThrottle.d.ts.map

package/dist/api/firmware/progressThrottle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"progressThrottle.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/progressThrottle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAS3E,eAAO,MAAM,8BAA8B,sCAKvB,MAAM,gBAAgB,2BAA2B,YA6BpE,CAAC"}

package/dist/protocols/protocol-v2/lockedError.d.ts

@@ -1,2 +0,0 @@
-export declare function isDeviceLockedError(error: unknown): boolean;
-//# sourceMappingURL=lockedError.d.ts.map

package/dist/protocols/protocol-v2/lockedError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lockedError.d.ts","sourceRoot":"","sources":["../../../src/protocols/protocol-v2/lockedError.ts"],"names":[],"mappings":"AAEA,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAO3D"}

package/dist/protocols/protocol-v2/unlockRetry.d.ts

@@ -1,10 +0,0 @@
-import type { BaseMethod } from '../../api/BaseMethod';
-import type { Device } from '../../device/Device';
-import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
-type RunnableMethod = Pick<BaseMethod, 'run' | 'unlockPolicy' | 'protocolV2UiInteraction' | 'protocolV2UiMode' | 'params' | 'payload' | 'useDevicePassphraseState'> & {
-    name?: string;
-};
-type UiInteractionCoordinator = Pick<ProtocolV2UiInteractionCoordinator, 'enterMethodInteraction' | 'enterUnlockInteraction' | 'resumeMethodInteraction'>;
-export declare function runMethodWithUnlockRetry(method: RunnableMethod, device: Device, uiCoordinator?: UiInteractionCoordinator): Promise<any>;
-export {};
-//# sourceMappingURL=unlockRetry.d.ts.map

package/dist/protocols/protocol-v2/unlockRetry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unlockRetry.d.ts","sourceRoot":"","sources":["../../../src/protocols/protocol-v2/unlockRetry.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iBAAiB,CAAC;AAI1E,KAAK,cAAc,GAAG,IAAI,CACxB,UAAU,EACR,KAAK,GACL,cAAc,GACd,yBAAyB,GACzB,kBAAkB,GAClB,QAAQ,GACR,SAAS,GACT,0BAA0B,CAC7B,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACtB,KAAK,wBAAwB,GAAG,IAAI,CAClC,kCAAkC,EAClC,wBAAwB,GAAG,wBAAwB,GAAG,yBAAyB,CAChF,CAAC;AAkBF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,wBAAwB,gBAoFzC"}

package/src/api/firmware/progressThrottle.ts

@@ -1,44 +0,0 @@
-import type { IFirmwareUpdateProgressType } from '../../events/ui-request';
-
-const DEFAULT_FIRMWARE_PROGRESS_INTERVAL_MS = 250;
-
-type FirmwareProgressThrottleState = {
-  lastEmittedAt: number;
-  lastProgress?: number;
-};
-
-export const createFirmwareProgressThrottle = (
-  intervalMs = DEFAULT_FIRMWARE_PROGRESS_INTERVAL_MS
-) => {
-  const stateByType = new Map<IFirmwareUpdateProgressType, FirmwareProgressThrottleState>();
-
-  return (progress: number, progressType: IFirmwareUpdateProgressType) => {
-    if (progressType !== 'transferData') {
-      return true;
-    }
-
-    const normalizedProgress = Math.max(0, Math.min(100, Math.floor(progress)));
-    if (normalizedProgress === 0 || normalizedProgress === 100) {
-      stateByType.set(progressType, {
-        lastEmittedAt: Date.now(),
-        lastProgress: normalizedProgress,
-      });
-      return true;
-    }
-
-    const now = Date.now();
-    const state = stateByType.get(progressType);
-    if (
-      state &&
-      (state.lastProgress === normalizedProgress || now - state.lastEmittedAt < intervalMs)
-    ) {
-      return false;
-    }
-
-    stateByType.set(progressType, {
-      lastEmittedAt: now,
-      lastProgress: normalizedProgress,
-    });
-    return true;
-  };
-};

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

@@ -1,10 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-export function isDeviceLockedError(error: unknown): boolean {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    'errorCode' in error &&
-    error.errorCode === HardwareErrorCode.DeviceLocked
-  );
-}

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

@@ -1,131 +0,0 @@
-import { LoggerNames, getLogger } from '../../utils';
-import { isDeviceLockedError } from './lockedError';
-import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
-import { refreshProtocolV2DeviceStatus, restoreProtocolV2WalletSession } from './walletSession';
-
-import type { BaseMethod } from '../../api/BaseMethod';
-import type { Device } from '../../device/Device';
-import type { HardwareUiInteractionMeta } from '../../events';
-import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
-
-const Log = getLogger(LoggerNames.Core);
-
-type RunnableMethod = Pick<
-  BaseMethod,
-  | 'run'
-  | 'unlockPolicy'
-  | 'protocolV2UiInteraction'
-  | 'protocolV2UiMode'
-  | 'params'
-  | 'payload'
-  | 'useDevicePassphraseState'
-> & { name?: string };
-type UiInteractionCoordinator = Pick<
-  ProtocolV2UiInteractionCoordinator,
-  'enterMethodInteraction' | 'enterUnlockInteraction' | 'resumeMethodInteraction'
->;
-
-const restoreExpectedWalletSessionAfterUnlock = async (method: RunnableMethod, device: Device) => {
-  const expectedPassphraseState = method.payload?.useEmptyPassphrase
-    ? undefined
-    : method.payload?.passphraseState ?? device.passphraseState;
-  if (
-    !method.useDevicePassphraseState ||
-    typeof expectedPassphraseState !== 'string' ||
-    expectedPassphraseState.length === 0
-  ) {
-    return;
-  }
-
-  await restoreProtocolV2WalletSession(device, expectedPassphraseState);
-  Log.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
-};
-
-export async function runMethodWithUnlockRetry(
-  method: RunnableMethod,
-  device: Device,
-  uiCoordinator?: UiInteractionCoordinator
-) {
-  const shouldEmitUi = isProtocolV2UiEnabled(method);
-  const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
-  const isProtocolV2 = device.isProtocolV2();
-  const requiresFreshStatus =
-    isProtocolV2 &&
-    method.unlockPolicy === 'unlock-before-run' &&
-    !device.isBootloader?.() &&
-    !device.isRomloader?.();
-
-  if (requiresFreshStatus) {
-    await refreshProtocolV2DeviceStatus(device);
-  }
-
-  const shouldUnlockBeforeRun =
-    isProtocolV2 &&
-    method.unlockPolicy !== 'none' &&
-    !device.isBootloader?.() &&
-    !device.isRomloader?.() &&
-    device.features?.unlocked === false;
-
-  if (shouldUnlockBeforeRun) {
-    const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
-      ? uiCoordinator?.enterUnlockInteraction(method.name)
-      : undefined;
-    await device.unlockDevice(
-      undefined,
-      shouldCoordinateUi
-        ? { emitUiEvent: false, interaction: unlockInteraction }
-        : {
-            source: 'unlock-coordinator',
-            reason: 'device-locked',
-            deviceOnly: true,
-            method: method.name,
-          }
-    );
-    Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
-    await restoreExpectedWalletSessionAfterUnlock(method, device);
-    if (shouldCoordinateUi) {
-      uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
-    }
-    return method.run();
-  }
-
-  if (shouldCoordinateUi) {
-    uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
-  }
-  try {
-    return await method.run();
-  } catch (error) {
-    if (!isProtocolV2 || method.unlockPolicy !== 'retry-on-locked' || !isDeviceLockedError(error)) {
-      throw error;
-    }
-
-    Log.debug('Protocol V2 unlock retry triggered', { method: method.name });
-    const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
-      ? uiCoordinator?.enterUnlockInteraction(method.name)
-      : undefined;
-    await device.unlockDevice(
-      undefined,
-      shouldCoordinateUi
-        ? { emitUiEvent: false, interaction: unlockInteraction }
-        : {
-            source: 'unlock-coordinator',
-            reason: 'device-locked',
-            deviceOnly: true,
-            method: method.name,
-          }
-    );
-    Log.debug('Protocol V2 unlock completed', { method: method.name });
-    await restoreExpectedWalletSessionAfterUnlock(method, device);
-    if (shouldCoordinateUi) {
-      uiCoordinator?.resumeMethodInteraction();
-    }
-    try {
-      const response = await method.run();
-      Log.debug('Protocol V2 method retry completed', { method: method.name, success: true });
-      return response;
-    } catch (retryError) {
-      Log.debug('Protocol V2 method retry completed', { method: method.name, success: false });
-      throw retryError;
-    }
-  }
-}