@onekeyfe/hd-core 1.2.0-alpha.9 → 1.2.0-alpha.90

package/src/utils/findDefectiveBatchDevice.ts

@@ -1,11 +1,11 @@
-import { getDeviceType, getDeviceUUID } from './deviceInfoUtils';
+import { getDeviceSerialNo, getDeviceType } from './deviceInfoUtils';
 
 import type { Features } from '../types';
 
 /**
  * 检测故障固件设备
  * 检测规则：
- * - 序列号范围：21032200001 到 21032201500
+ * - Serial number range: 21032200001 through 21032201500
  * - SE版本为 1.1.0.2
  *
  * 对齐之前版本的检测逻辑
@@ -27,7 +27,7 @@ export const findDefectiveBatchDevice = (features: Features) => {
  */
 export const getDefectiveDeviceInfo = (features: Features) => {
   if (!findDefectiveBatchDevice(features)) return null;
-  const serialNo = getDeviceUUID(features);
+  const serialNo = getDeviceSerialNo(features);
   const deviceType = getDeviceType(features);
   const { seVersion } = features;
 

package/src/utils/homescreen.ts

@@ -3,6 +3,13 @@ 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';
 
@@ -301,6 +308,35 @@ 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 },
+    },
+    neo: {
+      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,
@@ -310,6 +346,10 @@ export const getHomeScreenSize = ({
   homeScreenType: 'WallPaper' | 'Nft';
   thumbnail?: boolean;
 }) => {
+  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
+    return thumbnail ? undefined : { width: PRO2_WALLPAPER_WIDTH, height: PRO2_WALLPAPER_HEIGHT };
+  }
+
   const sizes: Partial<
     Record<
       IDeviceType,

package/src/utils/index.ts

@@ -8,10 +8,10 @@ export {
   getDeviceTypeByBleName,
   getDeviceType,
   getDeviceBleName,
+  getDeviceSerialNo,
   getDeviceUUID,
   getDeviceLabel,
   getMethodVersionRange,
-  isMethodVersionRangeUnsupported,
   getFirmwareType,
 } from './deviceInfoUtils';
 export {
@@ -29,7 +29,24 @@ export {
   checkNeedUpdateBootForTouch,
   checkNeedUpdateBootForClassicAndMini,
 } from '../api/firmware/updateBootloader';
-export { getLanguageConfig, getAutoLockOptions, getAutoShutDownOptions } from './deviceSettings';
+export {
+  DEVICE_SETTINGS_SHARED_FIELDS,
+  DEVICE_SETTINGS_V1_ONLY_FIELDS,
+  DEVICE_SETTINGS_V2_ONLY_FIELDS,
+  PROTOCOL_V2_NEVER_TIMEOUT_MS,
+  getAutoLockOptions,
+  getAutoShutDownOptions,
+  getDeviceSettingsCapabilities,
+  getLanguageConfig,
+  normalizeSafetyCheckLevel,
+} from './deviceSettings';
+export type {
+  DeviceSettingsCapabilities,
+  DeviceSettingsDurationOption,
+  DeviceSettingsField,
+  DeviceSettingsProtocol,
+  DeviceSettingsValueOption,
+} from './deviceSettings';
 
 // Helpers utils
 
@@ -37,7 +54,14 @@ 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';
 
 export const wait = (ms: number) =>
   new Promise(resolve => {

package/src/utils/networkUtils.ts

@@ -1,25 +1,283 @@
-import axios from 'axios';
+import axios, { type AxiosResponse } from 'axios';
 
-export const httpRequest = async (url: string, type = 'text') => {
-  const headers: any = {};
-  if (url.indexOf('ngrok-free.app') > -1) {
-    headers['ngrok-skip-browser-warning'] = true;
+export type HttpRequestOptions = {
+  /** Additional request headers, such as a byte range for package metadata reads. */
+  headers?: Record<string, string>;
+  /** Axios adapter-defined request timeout retained for existing opt-in callers. */
+  timeoutMs?: number;
+  /** Deadline for DNS, connection, TLS, redirects, and the first response-body progress. */
+  connectTimeoutMs?: number;
+  /** Maximum idle interval between response-body progress events. */
+  readTimeoutMs?: number;
+  /** Wall-clock deadline across all attempts and retry backoff. */
+  overallTimeoutMs?: number;
+  maxRetries?: number;
+  retryDelayMs?: number;
+};
+
+const MAX_RETRY_COUNT = 3;
+const REQUEST_PHASE_TIMEOUT_CODES = {
+  connect: 'ECONNECTTIMEDOUT',
+  read: 'EREADTIMEDOUT',
+} as const;
+const RETRYABLE_HTTP_STATUSES = new Set([500, 502, 503, 504]);
+const RETRYABLE_NETWORK_ERROR_CODES = new Set([
+  REQUEST_PHASE_TIMEOUT_CODES.connect,
+  REQUEST_PHASE_TIMEOUT_CODES.read,
+  'ECONNABORTED',
+  'ECONNREFUSED',
+  'ECONNRESET',
+  'EHOSTUNREACH',
+  'ENETDOWN',
+  'ENETUNREACH',
+  'ENOTFOUND',
+  'EAI_AGAIN',
+  'ERR_NETWORK',
+  'ETIMEDOUT',
+]);
+
+const createAbortError = () => {
+  const error = new Error('httpRequest aborted');
+  error.name = 'AbortError';
+  return error;
+};
+
+const createOverallTimeoutError = (url: string, timeoutMs: number) => {
+  const error = new Error(`httpRequest overall timeout: ${url} ${timeoutMs}ms`);
+  error.name = 'HttpRequestOverallTimeoutError';
+  return error;
+};
+
+const createRequestPhaseTimeoutError = (
+  url: string,
+  phase: keyof typeof REQUEST_PHASE_TIMEOUT_CODES,
+  timeoutMs: number
+) => {
+  const error = new Error(`httpRequest ${phase} timeout: ${url} ${timeoutMs}ms`);
+  error.name = 'HttpRequestPhaseTimeoutError';
+  return Object.assign(error, {
+    code: REQUEST_PHASE_TIMEOUT_CODES[phase],
+  });
+};
+
+const waitForRetry = async (delayMs: number, attempt: number, signal?: AbortSignal) => {
+  const backoffMs = delayMs * 2 ** attempt;
+  if (backoffMs <= 0) {
+    return;
   }
-  const response = await axios.request({
-    url,
-    withCredentials: false,
-    responseType: type === 'binary' ? 'arraybuffer' : 'json',
-    headers,
+  await new Promise<void>((resolve, reject) => {
+    const timeoutTimer = setTimeout(() => {
+      signal?.removeEventListener('abort', handleAbort);
+      resolve();
+    }, backoffMs);
+    const handleAbort = () => {
+      clearTimeout(timeoutTimer);
+      reject(createAbortError());
+    };
+    if (signal?.aborted) {
+      handleAbort();
+      return;
+    }
+    signal?.addEventListener('abort', handleAbort, { once: true });
   });
+};
 
-  if (+response.status === 200) {
-    if (type === 'json') {
-      return response.data;
+const isRetryableRequestError = (error: unknown) => {
+  if (axios.isCancel(error)) {
+    return false;
+  }
+  if (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    typeof error.code === 'string' &&
+    RETRYABLE_NETWORK_ERROR_CODES.has(error.code)
+  ) {
+    return true;
+  }
+  if (!axios.isAxiosError(error)) {
+    return false;
+  }
+  const status = error.response?.status;
+  if (status !== undefined) {
+    return RETRYABLE_HTTP_STATUSES.has(Number(status));
+  }
+  return false;
+};
+
+export const httpRequest = async <T = unknown>(
+  url: string,
+  type = 'text',
+  options: HttpRequestOptions = {}
+): Promise<T> => {
+  const headers: Record<string, string> = { ...options.headers };
+  if (url.indexOf('ngrok-free.app') > -1) {
+    headers['ngrok-skip-browser-warning'] = 'true';
+  }
+
+  const timeoutMs =
+    Number.isSafeInteger(options.timeoutMs) && Number(options.timeoutMs) > 0
+      ? Number(options.timeoutMs)
+      : undefined;
+  const connectTimeoutMs =
+    Number.isSafeInteger(options.connectTimeoutMs) && Number(options.connectTimeoutMs) > 0
+      ? Number(options.connectTimeoutMs)
+      : undefined;
+  const readTimeoutMs =
+    Number.isSafeInteger(options.readTimeoutMs) && Number(options.readTimeoutMs) > 0
+      ? Number(options.readTimeoutMs)
+      : undefined;
+  const overallTimeoutMs =
+    Number.isSafeInteger(options.overallTimeoutMs) && Number(options.overallTimeoutMs) > 0
+      ? Number(options.overallTimeoutMs)
+      : undefined;
+  const maxRetries =
+    Number.isSafeInteger(options.maxRetries) && Number(options.maxRetries) > 0
+      ? Math.min(Number(options.maxRetries), MAX_RETRY_COUNT)
+      : 0;
+  const retryDelayMs =
+    Number.isSafeInteger(options.retryDelayMs) && Number(options.retryDelayMs) > 0
+      ? Number(options.retryDelayMs)
+      : 0;
+  const overallTimeoutError = overallTimeoutMs
+    ? createOverallTimeoutError(url, overallTimeoutMs)
+    : undefined;
+  const overallDeadlineAt = overallTimeoutMs ? Date.now() + overallTimeoutMs : undefined;
+  const assertWithinOverallDeadline = () => {
+    if (overallDeadlineAt !== undefined && overallTimeoutError && Date.now() >= overallDeadlineAt) {
+      throw overallTimeoutError;
+    }
+  };
+
+  const request = async (attempt: number, signal?: AbortSignal): Promise<T> => {
+    assertWithinOverallDeadline();
+    if (signal?.aborted) {
+      throw createAbortError();
+    }
+
+    let response: AxiosResponse<T> | undefined;
+    let requestError: unknown;
+    let requestFailed = false;
+    let phaseTimeoutError: ReturnType<typeof createRequestPhaseTimeoutError> | undefined;
+    let phaseTimeoutTimer: ReturnType<typeof setTimeout> | undefined;
+    const hasPhaseDeadline = Boolean(connectTimeoutMs || readTimeoutMs);
+    const attemptController = signal || hasPhaseDeadline ? new AbortController() : undefined;
+    let attemptSettled = false;
+    let lastProgressLoaded = 0;
+    const handleParentAbort = () => {
+      attemptController?.abort();
+    };
+    const clearPhaseTimeout = () => {
+      if (phaseTimeoutTimer) {
+        clearTimeout(phaseTimeoutTimer);
+        phaseTimeoutTimer = undefined;
+      }
+    };
+    const armPhaseTimeout = (
+      phase: keyof typeof REQUEST_PHASE_TIMEOUT_CODES,
+      phaseTimeoutMs: number | undefined
+    ) => {
+      clearPhaseTimeout();
+      if (!phaseTimeoutMs || !attemptController) {
+        return;
+      }
+      phaseTimeoutTimer = setTimeout(() => {
+        phaseTimeoutError = createRequestPhaseTimeoutError(url, phase, phaseTimeoutMs);
+        attemptController.abort();
+      }, phaseTimeoutMs);
+    };
+
+    if (signal) {
+      signal.addEventListener('abort', handleParentAbort, { once: true });
+    }
+    armPhaseTimeout('connect', connectTimeoutMs);
+
+    try {
+      response = await axios.request<T>({
+        url,
+        withCredentials: false,
+        responseType: type === 'binary' ? 'arraybuffer' : 'json',
+        headers,
+        ...(timeoutMs ? { timeout: timeoutMs } : {}),
+        ...(attemptController ? { signal: attemptController.signal } : {}),
+        ...(hasPhaseDeadline
+          ? {
+              adapter: ['xhr', 'http'],
+              onDownloadProgress: (progressEvent: { loaded: number }) => {
+                if (
+                  attemptSettled ||
+                  attemptController?.signal.aborted ||
+                  !Number.isFinite(progressEvent.loaded) ||
+                  progressEvent.loaded <= lastProgressLoaded
+                ) {
+                  return;
+                }
+                lastProgressLoaded = progressEvent.loaded;
+                armPhaseTimeout('read', readTimeoutMs);
+              },
+            }
+          : {}),
+      });
+      if (phaseTimeoutError) {
+        requestFailed = true;
+        requestError = phaseTimeoutError;
+        response = undefined;
+      }
+    } catch (error) {
+      requestFailed = true;
+      requestError = phaseTimeoutError ?? (signal?.aborted ? createAbortError() : error);
+    } finally {
+      attemptSettled = true;
+      clearPhaseTimeout();
+      signal?.removeEventListener('abort', handleParentAbort);
+    }
+
+    assertWithinOverallDeadline();
+
+    if (requestFailed) {
+      if (attempt >= maxRetries || !isRetryableRequestError(requestError)) {
+        throw requestError;
+      }
+      await waitForRetry(retryDelayMs, attempt, signal);
+      assertWithinOverallDeadline();
+      return request(attempt + 1, signal);
     }
-    if (type === 'binary') {
+
+    if (!response) {
+      throw new Error(`httpRequest completed without a response: ${url}`);
+    }
+
+    if (+response.status >= 200 && +response.status < 300) {
       return response.data;
     }
-    return response.data;
+
+    if (RETRYABLE_HTTP_STATUSES.has(Number(response.status)) && attempt < maxRetries) {
+      await waitForRetry(retryDelayMs, attempt, signal);
+      assertWithinOverallDeadline();
+      return request(attempt + 1, signal);
+    }
+
+    throw new Error(`httpRequest error: ${url} ${response.statusText}`);
+  };
+
+  if (!overallTimeoutMs) {
+    return request(0);
+  }
+
+  const controller = new AbortController();
+  const requestPromise = request(0, controller.signal);
+  let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await new Promise<T>((resolve, reject) => {
+      timeoutTimer = setTimeout(() => {
+        reject(overallTimeoutError);
+        controller.abort();
+      }, overallTimeoutMs);
+      requestPromise.then(resolve, reject);
+    });
+  } finally {
+    if (timeoutTimer) {
+      clearTimeout(timeoutTimer);
+    }
   }
-  throw new Error(`httpRequest error: ${url} ${response.statusText}`);
 };

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,
+  };
+}