@onekeyfe/hd-core 1.2.0-alpha.67 → 1.2.0-alpha.69

package/src/utils/pro2Nft.ts

@@ -0,0 +1,142 @@
+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/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/__tests__/device-initialize-timeout.test.ts

@@ -1,56 +0,0 @@
-import { Device } from '../src/device/Device';
-import TransportManager from '../src/data-manager/TransportManager';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-function buildV1Device() {
-  const device = Object.create(Device.prototype) as Device;
-  const typedCall = jest.fn(() => Promise.resolve({ message: { device_id: 'device' } }));
-  Object.assign(device, {
-    commands: { typedCall },
-    stateStore: { getState: () => undefined },
-    isProtocolV2: () => false,
-    _updateFeatures: jest.fn(),
-    getInternalState: jest.fn(() => undefined),
-  });
-  return { device, typedCall };
-}
-
-describe('Device.initialize Protocol V1 timeout', () => {
-  beforeEach(() => {
-    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  test('passes a custom Initialize timeout through to typedCall', async () => {
-    const { device, typedCall } = buildV1Device();
-
-    await device.initialize({ timeoutMs: 2500 });
-
-    expect(typedCall).toHaveBeenCalledWith(
-      'Initialize',
-      'Features',
-      expect.objectContaining({ is_contains_attach: true }),
-      { timeoutMs: 2500 }
-    );
-  });
-
-  test('keeps the 25s Initialize timeout by default', async () => {
-    const { device, typedCall } = buildV1Device();
-
-    await device.initialize();
-
-    expect(typedCall).toHaveBeenCalledWith(
-      'Initialize',
-      'Features',
-      expect.objectContaining({ is_contains_attach: true }),
-      { timeoutMs: 25 * 1000 }
-    );
-  });
-});

package/__tests__/firmware-update/check-all-firmware-release.test.ts

@@ -1,175 +0,0 @@
-import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import CheckAllFirmwareRelease from '../../src/api/CheckAllFirmwareRelease';
-import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
-import {
-  getBleFirmwareReleaseInfo,
-  getBootloaderReleaseInfo,
-  getFirmwareReleaseInfo,
-} from '../../src/api/firmware/releaseHelper';
-
-jest.mock('../../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-jest.mock('../../src/api/firmware/FirmwareUpdatePlan', () => ({
-  buildFirmwareUpdatePlan: jest.fn(),
-  validateFirmwareUpdatePlanForceTargets: jest.fn(value => value ?? []),
-}));
-
-jest.mock('../../src/api/firmware/releaseHelper', () => ({
-  getBleFirmwareReleaseInfo: jest.fn(),
-  getBootloaderReleaseInfo: jest.fn(),
-  getFirmwareReleaseInfo: jest.fn(),
-}));
-
-const mockBuildFirmwareUpdatePlan = buildFirmwareUpdatePlan as jest.MockedFunction<
-  typeof buildFirmwareUpdatePlan
->;
-const mockGetBleFirmwareReleaseInfo = getBleFirmwareReleaseInfo as jest.MockedFunction<
-  typeof getBleFirmwareReleaseInfo
->;
-const mockGetBootloaderReleaseInfo = getBootloaderReleaseInfo as jest.MockedFunction<
-  typeof getBootloaderReleaseInfo
->;
-const mockGetFirmwareReleaseInfo = getFirmwareReleaseInfo as jest.MockedFunction<
-  typeof getFirmwareReleaseInfo
->;
-
-const noUpdate = {
-  status: 'valid' as const,
-  release: undefined,
-};
-
-const createMethod = (serialNo = 'device-id') => {
-  const method = new CheckAllFirmwareRelease({
-    id: 1,
-    payload: {
-      method: 'checkAllFirmwareRelease',
-      platform: 'native',
-    },
-  });
-  method.init();
-  method.device = {
-    isProtocolV2: jest.fn(() => false),
-    features: {
-      deviceType: EDeviceType.Classic1s,
-      serialNo,
-      firmwareType: EFirmwareType.Universal,
-      firmwareVersion: '1.0.0',
-      bootloaderVersion: '1.0.0',
-    },
-  } as typeof method.device;
-  return method;
-};
-
-const createMethodWithForceTargets = () => {
-  const method = createMethod();
-  method.payload = {
-    ...method.payload,
-    forceUpdateTargets: ['firmware', 'resource'],
-  };
-  return method;
-};
-
-describe('CheckAllFirmwareRelease', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockGetFirmwareReleaseInfo.mockReturnValue(noUpdate);
-    mockGetBootloaderReleaseInfo.mockReturnValue(noUpdate);
-    mockGetBleFirmwareReleaseInfo.mockReturnValue(noUpdate);
-  });
-
-  test('keeps release information available when an optional Plan cannot be built', async () => {
-    const firmware = {
-      status: 'outdated' as const,
-      release: {
-        url: 'https://firmware.onekey.so/classic/firmware.bin',
-        version: [3, 0, 0],
-      },
-    };
-    mockGetFirmwareReleaseInfo.mockReturnValue(firmware);
-    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
-      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Plan cannot be built', {
-        firmwareUpdateCode: 'FirmwarePlanInvalid',
-      });
-    });
-
-    await expect(createMethod('').run()).resolves.toEqual(
-      expect.objectContaining({
-        firmware,
-        bootloader: noUpdate,
-        ble: noUpdate,
-        firmwareUpdatePlan: undefined,
-      })
-    );
-  });
-
-  test('returns an optional Plan when the builder succeeds', async () => {
-    const plan = {
-      schemaVersion: 2 as const,
-      planDigest: 'a'.repeat(64),
-      executor: 'v3' as const,
-      deviceIdentity: 'device-id',
-      deviceModel: EDeviceType.Classic1s,
-      firmwareType: EFirmwareType.Universal,
-      platform: 'native' as const,
-      artifacts: [],
-      targetsToUpdate: [],
-    };
-    mockBuildFirmwareUpdatePlan.mockReturnValue(plan);
-
-    await expect(createMethod().run()).resolves.toEqual(
-      expect.objectContaining({
-        firmwareUpdatePlan: plan,
-      })
-    );
-  });
-
-  test('passes host-selected update targets to the Plan builder', async () => {
-    mockBuildFirmwareUpdatePlan.mockReturnValue({
-      schemaVersion: 2,
-      planDigest: 'a'.repeat(64),
-      executor: 'v2',
-      deviceIdentity: 'device-id',
-      deviceModel: EDeviceType.Classic1s,
-      firmwareType: EFirmwareType.Universal,
-      platform: 'native',
-      artifacts: [],
-      targetsToUpdate: [],
-    });
-
-    await createMethodWithForceTargets().run();
-
-    expect(mockBuildFirmwareUpdatePlan).toHaveBeenCalledWith(
-      expect.objectContaining({
-        forceUpdateTargets: ['firmware', 'resource'],
-      })
-    );
-  });
-
-  test('does not hide a Plan failure for an explicitly forced target', async () => {
-    const planError = ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Forced firmware target is unavailable',
-      {
-        firmwareUpdateCode: 'FirmwarePlanInvalid',
-      }
-    );
-    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
-      throw planError;
-    });
-
-    await expect(createMethodWithForceTargets().run()).rejects.toBe(planError);
-  });
-
-  test('does not hide unexpected Plan builder failures', async () => {
-    const unexpectedError = new Error('unexpected builder failure');
-    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
-      throw unexpectedError;
-    });
-
-    await expect(createMethod().run()).rejects.toBe(unexpectedError);
-  });
-});

package/__tests__/firmware-update/device-update-bootloader.test.ts

@@ -1,87 +0,0 @@
-import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import DeviceUpdateBootloader from '../../src/api/device/DeviceUpdateBootloader';
-import {
-  registerFirmwareUpdateHostBinding,
-  unregisterFirmwareUpdateHostBinding,
-} from '../../src/api/firmware/FirmwareHostBinding';
-
-jest.mock('../../src/api/firmware/FirmwareUpdatePreparedPlan', () => ({
-  assertFirmwareUpdatePreparedPlanBinding: jest.fn(),
-  assertFirmwareUpdatePreparedPlanDeviceIdentity: jest.fn(),
-}));
-
-jest.mock('../../src/data-manager', () => ({
-  DataManager: {
-    getSettings: jest.fn(),
-    isBleConnect: jest.fn(),
-  },
-}));
-
-jest.mock('../../src/device/DevicePool', () => ({
-  DevicePool: {},
-}));
-
-const artifact = {
-  artifactRef: `fw:${'a'.repeat(64)}`,
-  size: 4,
-  sha256: 'a'.repeat(64),
-};
-
-const createMethod = () => {
-  const closeError = new Error('artifact reader close failed');
-  const close = jest.fn().mockRejectedValue(closeError);
-  const artifactReader = {
-    open: jest.fn().mockResolvedValue({ readerId: 'reader-1', size: artifact.size }),
-    read: jest.fn(),
-    close,
-  };
-  const hostBindingGeneration = registerFirmwareUpdateHostBinding({ artifactReader });
-  const method = new DeviceUpdateBootloader({
-    id: 1,
-    payload: {
-      method: 'deviceUpdateBootloader',
-      artifact,
-      hostBindingGeneration,
-      preparedPlan: {},
-    },
-  });
-  (method as any).device = {
-    features: {
-      deviceType: EDeviceType.Touch,
-      serialNo: 'touch-device-id',
-    },
-    getCurrentDeviceType: () => EDeviceType.Touch,
-    getCurrentFirmwareType: () => EFirmwareType.Universal,
-  };
-  return { close, closeError, method };
-};
-
-describe('DeviceUpdateBootloader artifact source cleanup', () => {
-  afterEach(() => {
-    unregisterFirmwareUpdateHostBinding();
-    jest.restoreAllMocks();
-  });
-
-  test('does not replace a successful update result when source close fails', async () => {
-    const { close, method } = createMethod();
-    jest.spyOn(method, 'updateTouchBootloader').mockResolvedValue(true);
-
-    await expect(method.run()).resolves.toBe(true);
-
-    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
-  });
-
-  test('does not replace the original hardware error when source close fails', async () => {
-    const { close, method } = createMethod();
-    const hardwareError = ERRORS.TypedError(
-      HardwareErrorCode.FirmwareError,
-      'original bootloader hardware error'
-    );
-    jest.spyOn(method, 'updateTouchBootloader').mockRejectedValue(hardwareError);
-
-    await expect(method.run()).rejects.toBe(hardwareError);
-
-    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
-  });
-});