@onekeyfe/hd-core 1.2.0-alpha.53 → 1.2.0-alpha.54

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

@@ -1,118 +0,0 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
-
-import { LoggerNames, getLogger } from '../../utils';
-import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
-import { refreshProtocolV2DeviceStatus } 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);
-
-export type ProtocolV2UnlockContext = {
-  preflightCompleted: boolean;
-};
-
-export const createProtocolV2UnlockContext = (): ProtocolV2UnlockContext => ({
-  preflightCompleted: false,
-});
-
-type RunnableMethod = Pick<
-  BaseMethod,
-  | 'run'
-  | 'unlockPolicy'
-  | 'useDevicePassphraseState'
-  | 'protocolV2UiInteraction'
-  | 'protocolV2UiMode'
-  | 'params'
-  | 'payload'
-> & {
-  name?: string;
-  protocolV2UnlockContext?: ProtocolV2UnlockContext;
-};
-
-type UiInteractionCoordinator = Pick<
-  ProtocolV2UiInteractionCoordinator,
-  'enterMethodInteraction' | 'enterUnlockInteraction'
->;
-
-type RunMethodWithUnlockPolicyOptions<T> = {
-  context?: ProtocolV2UnlockContext;
-  uiCoordinator?: UiInteractionCoordinator;
-  afterStatusBeforeUnlock?: () => void | Promise<void>;
-  prepare?: () => Promise<void>;
-  run?: () => Promise<T>;
-};
-
-export async function runMethodWithUnlockPolicy<T = unknown>(
-  method: RunnableMethod,
-  device: Device,
-  options: RunMethodWithUnlockPolicyOptions<T> = {}
-): Promise<T> {
-  const {
-    context = createProtocolV2UnlockContext(),
-    uiCoordinator,
-    afterStatusBeforeUnlock,
-    prepare,
-    run: configuredRun,
-  } = options;
-  const run = configuredRun ?? (() => method.run() as Promise<T>);
-  method.protocolV2UnlockContext = context;
-
-  const shouldEmitUi = isProtocolV2UiEnabled(method);
-  const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
-  const requiresPreUnlock =
-    device.isProtocolV2() &&
-    (method.useDevicePassphraseState || method.unlockPolicy === 'unlock-before-run') &&
-    !device.isBootloader?.() &&
-    !device.isRomloader?.();
-
-  if (requiresPreUnlock && !context.preflightCompleted) {
-    const status = await refreshProtocolV2DeviceStatus(device);
-    if (typeof status?.unlocked !== 'boolean') {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 DeviceStatus did not report an explicit unlock state.'
-      );
-    }
-
-    await afterStatusBeforeUnlock?.();
-
-    if (!status.unlocked) {
-      const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
-        ? uiCoordinator.enterUnlockInteraction(method.name)
-        : undefined;
-      const unlockedStatus = await device.unlockDevice(
-        DeviceSessionPinType.Main,
-        shouldCoordinateUi
-          ? { emitUiEvent: false, interaction: unlockInteraction }
-          : {
-              source: 'unlock-coordinator',
-              reason: 'device-locked',
-              deviceOnly: true,
-              method: method.name,
-            }
-      );
-      if (unlockedStatus?.unlocked !== true) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Protocol V2 device remained locked after the unlock flow.'
-        );
-      }
-      Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
-    }
-
-    context.preflightCompleted = true;
-  }
-
-  await prepare?.();
-
-  if (shouldCoordinateUi) {
-    uiCoordinator.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
-  }
-
-  return run();
-}

package/src/types/api/detectDeviceConnectProtocol.ts

@@ -1,7 +0,0 @@
-import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
-
-import type { Response } from '../params';
-
-export declare function detectDeviceConnectProtocol(
-  connectId: string
-): Response<HardwareConnectProtocol>;

package/src/utils/pro2Nft.ts

@@ -1,142 +0,0 @@
-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 = 2048;
-export const PRO2_NFT_DEFAULT_PACE_MS = 0;
-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 const PRO2_NFT_MAX_ITEMS = 10;
-
-export type Pro2NftImage = {
-  width: number;
-  height: number;
-  rgba: Uint8Array | ArrayBuffer;
-};
-
-export type Pro2NftBundle = {
-  basename: string;
-  image: Uint8Array;
-  thumbnail: Uint8Array;
-  metadata: Uint8Array;
-};
-
-const PRO2_NFT_BASENAME_PATTERN = /^nft-[0-9a-f]{8}-[1-9][0-9]*$/;
-
-type Pro2NftFileType = 'image' | 'thumbnail' | 'metadata';
-
-function parsePro2NftFile(listedPath: string):
-  | {
-      basename: string;
-      fileType: Pro2NftFileType;
-    }
-  | undefined {
-  const filename = listedPath.trim().split('/').at(-1);
-  if (!filename) return undefined;
-
-  let basename: string | undefined;
-  let fileType: Pro2NftFileType | undefined;
-  if (filename.endsWith('_m.bin')) {
-    basename = filename.slice(0, -'_m.bin'.length);
-    fileType = 'thumbnail';
-  } else if (filename.endsWith('.json')) {
-    basename = filename.slice(0, -'.json'.length);
-    fileType = 'metadata';
-  } else if (filename.endsWith('.bin')) {
-    basename = filename.slice(0, -'.bin'.length);
-    fileType = 'image';
-  }
-
-  return basename && fileType && PRO2_NFT_BASENAME_PATTERN.test(basename)
-    ? { basename, fileType }
-    : undefined;
-}
-
-export function getCompletePro2NftBasenames(childFiles?: string): Set<string> {
-  const filesByBasename = new Map<string, Set<Pro2NftFileType>>();
-
-  for (const listedPath of childFiles?.split('\n') ?? []) {
-    const file = parsePro2NftFile(listedPath);
-    if (file) {
-      const fileTypes = filesByBasename.get(file.basename) ?? new Set<Pro2NftFileType>();
-      fileTypes.add(file.fileType);
-      filesByBasename.set(file.basename, fileTypes);
-    }
-  }
-
-  return new Set(
-    [...filesByBasename.entries()]
-      .filter(([, fileTypes]) => fileTypes.size === 3)
-      .map(([basename]) => basename)
-  );
-}
-
-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/uiProgressThrottle.ts

@@ -1,63 +0,0 @@
-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;
-  };
-};