@onekeyfe/hd-core 1.2.0-alpha.40 → 1.2.0-alpha.41

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

@@ -1,166 +0,0 @@
-import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
-
-import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
-import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
-import {
-  PRO2_NFT_DEFAULT_CHUNK_SIZE,
-  PRO2_NFT_DEFAULT_PACE_MS,
-  PRO2_NFT_DEFAULT_TIMEOUT_MS,
-  PRO2_NFT_DIRECTORY,
-  PRO2_NFT_MAX_CHUNK_SIZE,
-  PRO2_NFT_MIN_CHUNK_SIZE,
-  type Pro2NftBundle,
-  type Pro2NftImage,
-  buildPro2NftBundle,
-} from '../../utils/pro2Nft';
-import { BaseMethod } from '../BaseMethod';
-import { invalidParameter } from '../helpers/filesystemValidation';
-import { isProtocolV2ResponseTimeout, writeProtocolV2File } from '../helpers/protocolV2FileWrite';
-
-export type DeviceUploadNftParams = {
-  image: Pro2NftImage;
-  thumbnail: Pro2NftImage;
-  title: string;
-  subtitle: string;
-  timestampMs?: number;
-  chunkSize?: number;
-  paceMs?: number;
-  timeoutMs?: number;
-};
-
-export type DeviceUploadNftResponse = {
-  basename: string;
-  imagePath: string;
-  thumbnailPath: string;
-  metadataPath: string;
-  totalSize: number;
-  nftUpdated: true;
-  message?: string;
-};
-
-const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
-const NFT_UPDATE_MESSAGE_TYPE = 61500;
-
-export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
-  private bundle?: Pro2NftBundle;
-
-  getSupportedProtocols() {
-    return ['V2'] as const;
-  }
-
-  init() {
-    const {
-      image,
-      thumbnail,
-      title,
-      subtitle,
-      timestampMs = Date.now(),
-      chunkSize = PRO2_NFT_DEFAULT_CHUNK_SIZE,
-      paceMs = PRO2_NFT_DEFAULT_PACE_MS,
-      timeoutMs = PRO2_NFT_DEFAULT_TIMEOUT_MS,
-    } = this.payload;
-    if (
-      !Number.isInteger(chunkSize) ||
-      chunkSize < PRO2_NFT_MIN_CHUNK_SIZE ||
-      chunkSize > PRO2_NFT_MAX_CHUNK_SIZE
-    ) {
-      throw invalidParameter(
-        `Parameter [chunkSize] must be an integer between ${PRO2_NFT_MIN_CHUNK_SIZE} and ${PRO2_NFT_MAX_CHUNK_SIZE}.`
-      );
-    }
-    if (!Number.isInteger(paceMs) || paceMs < 0) {
-      throw invalidParameter('Parameter [paceMs] must be a non-negative integer.');
-    }
-    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
-      throw invalidParameter('Parameter [timeoutMs] must be a positive integer.');
-    }
-
-    this.bundle = buildPro2NftBundle({ image, thumbnail, title, subtitle, timestampMs });
-    this.params = { image, thumbnail, title, subtitle, timestampMs, chunkSize, paceMs, timeoutMs };
-    this.unlockPolicy = 'none';
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-  }
-
-  private async assertCapabilities() {
-    const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
-    const hasFileWrite = supportsProtocolV2Message(
-      protocolInfo,
-      FILESYSTEM_FILE_WRITE_MESSAGE_TYPE
-    );
-    const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
-    if (!hasFileWrite || !hasNftUpdate) {
-      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-    }
-  }
-
-  private async updateNft(basename: string) {
-    const params = { file_name_no_ext: basename };
-    const options = { timeoutMs: this.params.timeoutMs };
-    try {
-      return await this.device.commands.typedCall('NftUpdate', 'Success', params, options);
-    } catch (error) {
-      if (!isProtocolV2ResponseTimeout(error)) {
-        throw error;
-      }
-      this.throwIfAborted();
-      return this.device.commands.typedCall('NftUpdate', 'Success', params, options);
-    }
-  }
-
-  async run(): Promise<DeviceUploadNftResponse> {
-    const { bundle } = this;
-    if (!bundle) throw invalidParameter('NFT data has not been initialized.');
-
-    await this.assertCapabilities();
-
-    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 totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
-    let transferredBeforeFile = 0;
-
-    for (const file of files) {
-      const transferredAtFileStart = transferredBeforeFile;
-      await writeProtocolV2File({
-        commands: this.device.commands,
-        path: file.path,
-        data: file.data,
-        totalSize: file.data.byteLength,
-        chunkSize: this.params.chunkSize,
-        timeoutMs: this.params.timeoutMs,
-        paceMs: this.params.paceMs,
-        overwrite: true,
-        append: false,
-        throwIfAborted: () => this.throwIfAborted(),
-        onProgress: progress => {
-          if (typeof this.postMessage !== 'function') return;
-          const transferredBytes = transferredAtFileStart + progress.transferredBytes;
-          this.postMessage(
-            createUiMessage(UI_REQUEST.DEVICE_PROGRESS, {
-              ...progress,
-              progress: Math.floor((transferredBytes / totalSize) * 100),
-              transferredBytes,
-              totalBytes: totalSize,
-            })
-          );
-        },
-      });
-      transferredBeforeFile += file.data.byteLength;
-    }
-
-    this.throwIfAborted();
-    const response = await this.updateNft(bundle.basename);
-    return {
-      basename: bundle.basename,
-      imagePath: files[0].path,
-      thumbnailPath: files[1].path,
-      metadataPath: files[2].path,
-      totalSize,
-      nftUpdated: true,
-      message: response.message?.message,
-    };
-  }
-}

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

@@ -1,117 +0,0 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-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(
-        undefined,
-        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/utils/pro2Nft.ts

@@ -1,91 +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 = 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/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;
-  };
-};