@onekeyfe/hd-core 1.1.34-alpha.0 → 1.1.34-alpha.2

package/dist/index.js

@@ -939,30 +939,230 @@ const LoggerMap = {
 };
 const getLogger = (key) => LoggerMap[key];
 
-const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0, function* () {
+const MAX_RETRY_COUNT = 3;
+const REQUEST_PHASE_TIMEOUT_CODES = {
+    connect: 'ECONNECTTIMEDOUT',
+    read: 'EREADTIMEDOUT',
+};
+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, timeoutMs) => {
+    const error = new Error(`httpRequest overall timeout: ${url} ${timeoutMs}ms`);
+    error.name = 'HttpRequestOverallTimeoutError';
+    return error;
+};
+const createRequestPhaseTimeoutError = (url, phase, timeoutMs) => {
+    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 = (delayMs, attempt, signal) => __awaiter(void 0, void 0, void 0, function* () {
+    const backoffMs = delayMs * Math.pow(2, attempt);
+    if (backoffMs <= 0) {
+        return;
+    }
+    yield new Promise((resolve, reject) => {
+        const timeoutTimer = setTimeout(() => {
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', handleAbort);
+            resolve();
+        }, backoffMs);
+        const handleAbort = () => {
+            clearTimeout(timeoutTimer);
+            reject(createAbortError());
+        };
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            handleAbort();
+            return;
+        }
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', handleAbort, { once: true });
+    });
+});
+const isRetryableRequestError = (error) => {
+    var _a;
+    if (axios__default["default"].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__default["default"].isAxiosError(error)) {
+        return false;
+    }
+    const status = (_a = error.response) === null || _a === void 0 ? void 0 : _a.status;
+    if (status !== undefined) {
+        return RETRYABLE_HTTP_STATUSES.has(Number(status));
+    }
+    return false;
+};
+const httpRequest$1 = (url, type = 'text', options = {}) => __awaiter(void 0, void 0, void 0, function* () {
     const headers = {};
     if (url.indexOf('ngrok-free.app') > -1) {
         headers['ngrok-skip-browser-warning'] = true;
     }
-    const response = yield axios__default["default"].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;
         }
-        if (type === 'binary') {
+    };
+    const request = (attempt, signal) => __awaiter(void 0, void 0, void 0, function* () {
+        assertWithinOverallDeadline();
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw createAbortError();
+        }
+        let response;
+        let requestError;
+        let requestFailed = false;
+        let phaseTimeoutError;
+        let phaseTimeoutTimer;
+        const hasPhaseDeadline = Boolean(connectTimeoutMs || readTimeoutMs);
+        const attemptController = signal || hasPhaseDeadline ? new AbortController() : undefined;
+        let attemptSettled = false;
+        let lastProgressLoaded = 0;
+        const handleParentAbort = () => {
+            attemptController === null || attemptController === void 0 ? void 0 : attemptController.abort();
+        };
+        const clearPhaseTimeout = () => {
+            if (phaseTimeoutTimer) {
+                clearTimeout(phaseTimeoutTimer);
+                phaseTimeoutTimer = undefined;
+            }
+        };
+        const armPhaseTimeout = (phase, phaseTimeoutMs) => {
+            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 = yield axios__default["default"].request(Object.assign(Object.assign(Object.assign({ url, withCredentials: false, responseType: type === 'binary' ? 'arraybuffer' : 'json', headers }, (timeoutMs ? { timeout: timeoutMs } : {})), (attemptController ? { signal: attemptController.signal } : {})), (hasPhaseDeadline
+                ? {
+                    adapter: ['xhr', 'http'],
+                    onDownloadProgress: (progressEvent) => {
+                        if (attemptSettled ||
+                            (attemptController === null || attemptController === void 0 ? void 0 : 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 !== null && phaseTimeoutError !== void 0 ? phaseTimeoutError : ((signal === null || signal === void 0 ? void 0 : signal.aborted) ? createAbortError() : error);
+        }
+        finally {
+            attemptSettled = true;
+            clearPhaseTimeout();
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', handleParentAbort);
+        }
+        assertWithinOverallDeadline();
+        if (requestFailed) {
+            if (attempt >= maxRetries || !isRetryableRequestError(requestError)) {
+                throw requestError;
+            }
+            yield waitForRetry(retryDelayMs, attempt, signal);
+            assertWithinOverallDeadline();
+            return request(attempt + 1, signal);
+        }
+        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) {
+            yield 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;
+    try {
+        return yield new Promise((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}`);
 });
 
-const httpRequest = (url, type) => httpRequest$1(url, type);
+const httpRequest = (url, type, options) => httpRequest$1(url, type, options);
 const getTimeStamp = () => new Date().getTime();
 
 const VER_NUMS = 3;
@@ -29699,7 +29899,7 @@ class DeviceWipe extends BaseMethod {
     }
 }
 
-const getBinary = ({ features, updateType, version, isUpdateBootloader, firmwareType, }) => __awaiter(void 0, void 0, void 0, function* () {
+const getBinary = ({ features, updateType, version, isUpdateBootloader, firmwareType, requestOptions, }) => __awaiter(void 0, void 0, void 0, function* () {
     const releaseInfo = getInfo({
         features,
         updateType,
@@ -29723,7 +29923,7 @@ const getBinary = ({ features, updateType, version, isUpdateBootloader, firmware
             : releaseInfo.url;
     let fw;
     try {
-        fw = yield httpRequest(url, 'binary');
+        fw = yield httpRequest(url, 'binary', requestOptions);
     }
     catch (_a) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
@@ -30793,6 +30993,59 @@ class FirmwareUpdate extends BaseMethod {
 }
 
 const Log$5 = getLogger(exports.LoggerNames.Method);
+const FIRMWARE_DOWNLOAD_REQUEST_OPTIONS = {
+    connectTimeoutMs: 60000,
+    readTimeoutMs: 60000,
+    overallTimeoutMs: 180000,
+    maxRetries: 2,
+    retryDelayMs: 500,
+};
+const normalizeFirmwareBinary = (binary) => {
+    var _a;
+    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;
+    if (typeof ((_a = customBuffer.constructor) === null || _a === void 0 ? void 0 : _a.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;
+};
 class FirmwareUpdateV2 extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -30973,7 +31226,7 @@ class FirmwareUpdateV2 extends BaseMethod {
         }
     }
     run() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         return __awaiter(this, void 0, void 0, function* () {
             const { device, params } = this;
             const { features, commands } = device;
@@ -30981,6 +31234,43 @@ class FirmwareUpdateV2 extends BaseMethod {
             const deviceFirmwareType = getFirmwareType(device.features);
             const firmwareType = (_a = params.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
             this.checkVersionForCopyTouchResource(features, firmwareType);
+            let preparedBinary;
+            const acquireFirmwareBinary = () => __awaiter(this, void 0, void 0, function* () {
+                var _l;
+                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 hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no features found for this device');
+                    }
+                    this.postTipMessage('DownloadFirmware');
+                    const firmware = yield 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 hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_l = err.message) !== null && _l !== void 0 ? _l : err);
+                }
+            });
             if (!(features === null || features === void 0 ? void 0 : features.bootloader_mode) && features) {
                 const uuid = getDeviceUUID(features);
                 if (this.isEnteredManuallyBoot(features)) {
@@ -31003,6 +31293,8 @@ class FirmwareUpdateV2 extends BaseMethod {
                     }
                 }
                 (_c = (_b = this.device) === null || _b === void 0 ? void 0 : _b.commands) === null || _c === void 0 ? void 0 : _c.checkDisposed();
+                yield acquireFirmwareBinary();
+                (_e = (_d = this.device) === null || _d === void 0 ? void 0 : _d.commands) === null || _e === void 0 ? void 0 : _e.checkDisposed();
                 try {
                     this.postTipMessage('AutoRebootToBootloader');
                     const bootRes = yield commands.typedCall('DeviceBackToBoot', 'Success');
@@ -31015,9 +31307,9 @@ class FirmwareUpdateV2 extends BaseMethod {
                         DevicePool.clearDeviceCache(uuid);
                     }
                     delete DevicePool.devicesCache[''];
-                    yield ((_d = this.checkPromise) === null || _d === void 0 ? void 0 : _d.promise);
+                    yield ((_f = this.checkPromise) === null || _f === void 0 ? void 0 : _f.promise);
                     this.checkPromise = null;
-                    (_f = (_e = this.device) === null || _e === void 0 ? void 0 : _e.commands) === null || _f === void 0 ? void 0 : _f.checkDisposed();
+                    (_h = (_g = this.device) === null || _g === void 0 ? void 0 : _g.commands) === null || _h === void 0 ? void 0 : _h.checkDisposed();
                     const isTouch = DeviceModelToTypes.model_touch.includes(deviceType);
                     yield wait(isTouch ? 3000 : 1500);
                 }
@@ -31029,31 +31321,8 @@ class FirmwareUpdateV2 extends BaseMethod {
                     return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure));
                 }
             }
-            let binary;
-            try {
-                if (params.binary) {
-                    binary = this.params.binary;
-                }
-                else {
-                    if (!device.features) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no features found for this device');
-                    }
-                    this.postTipMessage('DownloadFirmware');
-                    const firmware = yield getBinary({
-                        features: device.features,
-                        version: params.version,
-                        updateType: params.updateType,
-                        isUpdateBootloader: params.isUpdateBootloader,
-                        firmwareType,
-                    });
-                    binary = firmware.binary;
-                    this.postTipMessage('DownloadFirmwareSuccess');
-                }
-            }
-            catch (err) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_g = err.message) !== null && _g !== void 0 ? _g : err);
-            }
-            (_j = (_h = this.device) === null || _h === void 0 ? void 0 : _h.commands) === null || _j === void 0 ? void 0 : _j.checkDisposed();
+            const binary = yield acquireFirmwareBinary();
+            (_k = (_j = this.device) === null || _j === void 0 ? void 0 : _j.commands) === null || _k === void 0 ? void 0 : _k.checkDisposed();
             yield this.device.acquire();
             const response = yield uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, { payload: binary, rebootOnSuccess: true }, params.isUpdateBootloader);
             if (this.connectId) {
@@ -41631,6 +41900,11 @@ function connectDeviceForBle(method, device, retryCount = 0) {
             }
         }
         catch (err) {
+            if (hdShared.ERROR_CODES_REQUIRE_DISCONNECT.includes(err.errorCode) &&
+                device.mainId &&
+                device.deviceConnector) {
+                yield device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
+            }
             if (err.errorCode === hdShared.HardwareErrorCode.BleTimeoutError && retryCount < 6) {
                 const nextRetry = retryCount + 1;
                 Log.debug(`Bluetooth connect timeout and will retry, retry count: ${nextRetry}`);

package/dist/utils/assets.d.ts

@@ -1,3 +1,4 @@
-export declare const httpRequest: (url: string, type: string) => any;
+import type { HttpRequestOptions } from './networkUtils';
+export declare const httpRequest: (url: string, type: string, options?: HttpRequestOptions) => any;
 export declare const getTimeStamp: () => number;
 //# sourceMappingURL=assets.d.ts.map

package/dist/utils/assets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/utils/assets.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,QAAS,MAAM,QAAQ,MAAM,KAAG,GAAoC,CAAC;AAE7F,eAAO,MAAM,YAAY,cAA6B,CAAC"}
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/utils/assets.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,eAAO,MAAM,WAAW,QAAS,MAAM,QAAQ,MAAM,YAAY,kBAAkB,KAAG,GAC9C,CAAC;AAEzC,eAAO,MAAM,YAAY,cAA6B,CAAC"}

package/dist/utils/networkUtils.d.ts

@@ -1,2 +1,10 @@
-export declare const httpRequest: (url: string, type?: string) => Promise<any>;
+export type HttpRequestOptions = {
+    timeoutMs?: number;
+    connectTimeoutMs?: number;
+    readTimeoutMs?: number;
+    overallTimeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+};
+export declare const httpRequest: <T = unknown>(url: string, type?: string, options?: HttpRequestOptions) => Promise<T>;
 //# sourceMappingURL=networkUtils.d.ts.map

package/dist/utils/networkUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"networkUtils.d.ts","sourceRoot":"","sources":["../../src/utils/networkUtils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,QAAe,MAAM,gCAsB5C,CAAC"}
+{"version":3,"file":"networkUtils.d.ts","sourceRoot":"","sources":["../../src/utils/networkUtils.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,kBAAkB,GAAG;IAE/B,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AA4FF,eAAO,MAAM,WAAW,qBACjB,MAAM,2BAEF,kBAAkB,eA4K5B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.1.34-alpha.0",
+  "version": "1.1.34-alpha.2",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.1.34-alpha.0",
-    "@onekeyfe/hd-transport": "1.1.34-alpha.0",
+    "@onekeyfe/hd-shared": "1.1.34-alpha.2",
+    "@onekeyfe/hd-transport": "1.1.34-alpha.2",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "bytebuffer": "^5.0.1",
@@ -44,5 +44,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "178851631a3d06dd52c8dd9df24cbaaff7aa6390"
+  "gitHead": "dee167c35d191f3f4e02c4cb6228e1f926f929ec"
 }

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();