@onekeyfe/hd-core 1.1.32 → 1.1.34-alpha.1

package/src/api/FirmwareUpdateV2.ts

@@ -31,6 +31,7 @@ import { DEVICE } from '../events';
 
 import type { Features, KnownDevice } from '../types';
 import type { Device } from '../device/Device';
+import type { FirmwareBinary } from './firmware/getBinary';
 
 type Params = {
   binary?: ArrayBuffer;
@@ -43,6 +44,77 @@ type Params = {
 
 const Log = getLogger(LoggerNames.Method);
 
+const FIRMWARE_DOWNLOAD_REQUEST_OPTIONS = {
+  connectTimeoutMs: 60_000,
+  readTimeoutMs: 60_000,
+  overallTimeoutMs: 180_000,
+  maxRetries: 2,
+  retryDelayMs: 500,
+} as const;
+
+const normalizeFirmwareBinary = (binary: unknown): FirmwareBinary | undefined => {
+  if (typeof binary !== 'object' || binary === null) {
+    return undefined;
+  }
+
+  const isNodeBuffer =
+    typeof Buffer !== 'undefined' &&
+    typeof Buffer.isBuffer === 'function' &&
+    Buffer.isBuffer(binary);
+  if (isNodeBuffer) {
+    return binary.byteLength > 0 ? binary : undefined;
+  }
+
+  if (typeof ArrayBuffer !== 'undefined' && binary instanceof ArrayBuffer) {
+    return binary.byteLength > 0 ? binary : undefined;
+  }
+
+  if (
+    typeof ArrayBuffer !== 'undefined' &&
+    typeof ArrayBuffer.isView === 'function' &&
+    ArrayBuffer.isView(binary)
+  ) {
+    if (binary.byteLength <= 0) {
+      return undefined;
+    }
+    const source = new Uint8Array(binary.buffer, binary.byteOffset, binary.byteLength);
+    const normalized = new Uint8Array(binary.byteLength);
+    normalized.set(source);
+    return normalized.buffer;
+  }
+
+  const customBuffer = binary as {
+    [index: number]: unknown;
+    byteLength?: unknown;
+    constructor?: {
+      isBuffer?: (value: unknown) => boolean;
+    };
+    length?: unknown;
+  };
+  if (
+    typeof customBuffer.constructor?.isBuffer !== 'function' ||
+    !customBuffer.constructor.isBuffer(binary) ||
+    typeof customBuffer.byteLength !== 'number' ||
+    !Number.isSafeInteger(customBuffer.byteLength) ||
+    customBuffer.byteLength <= 0 ||
+    typeof customBuffer.length !== 'number' ||
+    customBuffer.length !== customBuffer.byteLength
+  ) {
+    return undefined;
+  }
+
+  const { byteLength } = customBuffer;
+  const normalized = new Uint8Array(byteLength);
+  for (let index = 0; index < byteLength; index += 1) {
+    const { [index]: byte } = customBuffer;
+    if (typeof byte !== 'number' || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+      return undefined;
+    }
+    normalized[index] = byte;
+  }
+  return normalized.buffer;
+};
+
 export default class FirmwareUpdateV2 extends BaseMethod<Params> {
   checkPromise: Deferred<any> | null = null;
 
@@ -286,6 +358,48 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
 
     this.checkVersionForCopyTouchResource(features, firmwareType);
 
+    let preparedBinary: FirmwareBinary | undefined;
+    const acquireFirmwareBinary = async (): Promise<FirmwareBinary> => {
+      try {
+        if (preparedBinary) {
+          return preparedBinary;
+        }
+
+        if (params.binary !== undefined) {
+          preparedBinary = normalizeFirmwareBinary(params.binary);
+          if (!preparedBinary) {
+            throw new Error('firmware binary is empty or invalid');
+          }
+          return preparedBinary;
+        }
+
+        if (!device.features) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'no features found for this device'
+          );
+        }
+
+        this.postTipMessage('DownloadFirmware');
+        const firmware = await getBinary({
+          features: device.features,
+          version: params.version,
+          updateType: params.updateType,
+          isUpdateBootloader: params.isUpdateBootloader,
+          firmwareType,
+          requestOptions: FIRMWARE_DOWNLOAD_REQUEST_OPTIONS,
+        });
+        preparedBinary = normalizeFirmwareBinary(firmware.binary);
+        if (!preparedBinary) {
+          throw new Error('downloaded firmware binary is empty or invalid');
+        }
+        this.postTipMessage('DownloadFirmwareSuccess');
+        return preparedBinary;
+      } catch (err) {
+        throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
+      }
+    };
+
     if (!features?.bootloader_mode && features) {
       const uuid = getDeviceUUID(features);
       // should go to bootloader mode manually
@@ -319,6 +433,12 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       // check if the device commands has been disposed
       this.device?.commands?.checkDisposed();
 
+      // A failed firmware download must leave the device in normal mode.
+      await acquireFirmwareBinary();
+
+      // The request may outlive the current transport command instance.
+      this.device?.commands?.checkDisposed();
+
       // auto go to bootloader mode
       try {
         this.postTipMessage('AutoRebootToBootloader');
@@ -357,33 +477,8 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       }
     }
 
-    let binary;
-
-    try {
-      if (params.binary) {
-        binary = this.params.binary;
-      } else {
-        if (!device.features) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.RuntimeError,
-            'no features found for this device'
-          );
-        }
-        this.postTipMessage('DownloadFirmware');
-
-        const firmware = await getBinary({
-          features: device.features,
-          version: params.version,
-          updateType: params.updateType,
-          isUpdateBootloader: params.isUpdateBootloader,
-          firmwareType,
-        });
-        binary = firmware.binary;
-        this.postTipMessage('DownloadFirmwareSuccess');
-      }
-    } catch (err) {
-      throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
-    }
+    // Devices already in bootloader mode still acquire through the same helper.
+    const binary = await acquireFirmwareBinary();
 
     // check if the device commands has been disposed
     this.device?.commands?.checkDisposed();

package/src/api/firmware/getBinary.ts

@@ -7,9 +7,12 @@ import { findLatestRelease } from '../../utils/release';
 import { getFirmwareUpdateField } from '../../utils/deviceFeaturesUtils';
 
 import type { Features } from '../../types';
+import type { HttpRequestOptions } from '../../utils/networkUtils';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { IFirmwareField } from '../../data-manager/DataManager';
 
+export type FirmwareBinary = ArrayBuffer | Buffer;
+
 export interface GetInfoProps {
   features: Features;
   updateType: 'firmware' | 'ble';
@@ -20,6 +23,7 @@ export interface GetInfoProps {
 
 interface GetBinaryProps extends GetInfoProps {
   version?: number[];
+  requestOptions?: HttpRequestOptions;
 }
 
 export const getBinary = async ({
@@ -28,6 +32,7 @@ export const getBinary = async ({
   version,
   isUpdateBootloader,
   firmwareType,
+  requestOptions,
 }: GetBinaryProps) => {
   const releaseInfo = getInfo({
     features,
@@ -55,9 +60,9 @@ export const getBinary = async ({
       : isUpdateBootloader
       ? releaseInfo.bootloaderResource
       : releaseInfo.url;
-  let fw;
+  let fw: FirmwareBinary;
   try {
-    fw = await httpRequest(url, 'binary');
+    fw = await httpRequest(url, 'binary', requestOptions);
   } catch {
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
   }
@@ -69,7 +74,7 @@ export const getBinary = async ({
 };
 
 export const getSysResourceBinary = async (url: string) => {
-  let fw;
+  let fw: FirmwareBinary;
   try {
     fw = await httpRequest(url, 'binary');
   } catch {

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -476,7 +476,18 @@ export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactio
           'KaspaSignTransaction: device firmware uses the streaming protocol; every output requires address or addressN'
         );
       }
-      return this.signTxStream(typedCall, response);
+      try {
+        return await this.signTxStream(typedCall, response);
+      } catch (error) {
+        // Device rejected our refTxs; the caller decides whether to sign without them.
+        if (
+          error instanceof HardwareError &&
+          String(error.message).toLowerCase().includes('previous transaction id mismatch')
+        ) {
+          throw ERRORS.TypedError(HardwareErrorCode.KaspaPrevTxIdMismatch, String(error.message));
+        }
+        throw error;
+      }
     }
 
     // Legacy answer to a streaming-only packet: no prehash material exists.

package/src/utils/assets.ts

@@ -1,5 +1,8 @@
 import { httpRequest as browserHttpRequest } from './networkUtils';
 
-export const httpRequest = (url: string, type: string): any => browserHttpRequest(url, type);
+import type { HttpRequestOptions } from './networkUtils';
+
+export const httpRequest = (url: string, type: string, options?: HttpRequestOptions): any =>
+  browserHttpRequest(url, type, options);
 
 export const getTimeStamp = () => new Date().getTime();

package/src/utils/networkUtils.ts

@@ -1,25 +1,281 @@
-import axios from 'axios';
+import axios, { type AxiosResponse } from 'axios';
 
-export const httpRequest = async (url: string, type = 'text') => {
+export type HttpRequestOptions = {
+  /** 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;
+  }
+  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 });
+  });
+};
+
+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: any = {};
   if (url.indexOf('ngrok-free.app') > -1) {
     headers['ngrok-skip-browser-warning'] = true;
   }
-  const response = await axios.request({
-    url,
-    withCredentials: false,
-    responseType: type === 'binary' ? 'arraybuffer' : 'json',
-    headers,
-  });
 
-  if (+response.status === 200) {
-    if (type === 'json') {
-      return response.data;
+  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) {
       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}`);
 };