@onekeyfe/hd-core 1.2.8-alpha.119 → 1.2.8-alpha.120

package/dist/index.js

@@ -40784,6 +40784,9 @@ class Log$n {
 }
 const _logs = {};
 const initLog = (prefix, enabled) => {
+    const existing = _logs[prefix];
+    if (existing)
+        return existing;
     const instance = new Log$n(prefix, !!enabled);
     _logs[prefix] = instance;
     return instance;
@@ -52631,6 +52634,8 @@ const PROTOCOL_V2_CONNECT_POLL_INTERVAL = 500;
 const PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT = 75 * 1000;
 const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
+const PROTOCOL_V2_RESOURCE_HEADER_RECOVERY_LIMIT = 2;
+const PROTOCOL_V2_BLE_FILE_WRITE_WINDOW_MIN_BOOTLOADER_VERSION = '1.0.4';
 const PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS = 1000;
 const PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE = 'FirmwareInstallStatusConflict';
 const PROTOCOL_V2_INSTALL_FAILED_CODE = 'FirmwareInstallFailed';
@@ -52678,6 +52683,11 @@ function assertProtocolV2FirmwareTargetsSupported(deviceType, params, hasExplici
         : `Cannot safely update ${targetList} without a confirmed Pro2 device type`;
     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportMethod, message);
 }
+function supportsProtocolV2BleFileWriteWindow(bootloaderVersion, minBootloaderVersion = PROTOCOL_V2_BLE_FILE_WRITE_WINDOW_MIN_BOOTLOADER_VERSION) {
+    return (!!minBootloaderVersion &&
+        !!semver__default["default"].valid(bootloaderVersion) &&
+        semver__default["default"].gte(bootloaderVersion, minBootloaderVersion));
+}
 const getProtocolV2DeviceTransferProgress = (bytesBeforeChunk, bytesAfterChunk, totalBytes) => {
     if (!Number.isFinite(totalBytes) || totalBytes <= 0) {
         return 0;
@@ -52687,6 +52697,8 @@ const getProtocolV2DeviceTransferProgress = (bytesBeforeChunk, bytesAfterChunk,
     }
     return Math.min(Math.max(Math.ceil((bytesAfterChunk / totalBytes) * 100), 1), 99);
 };
+const getProtocolV2TransferRate = (bytes, elapsedMs) => elapsedMs > 0 ? Math.round((bytes / elapsedMs) * 1000) : undefined;
+const getProtocolV2ElapsedMs = (startedAt, now = Date.now()) => Math.max(now - startedAt, 0);
 const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS = {
     BOOTLOADER: {
         fileName: 'bootloader.bin',
@@ -52787,6 +52799,21 @@ const getProtocolV2ErrorCode = (error) => {
     const causeCode = errorCode !== null && errorCode !== void 0 ? errorCode : code;
     return typeof causeCode === 'number' || typeof causeCode === 'string' ? causeCode : undefined;
 };
+const isProtocolV2ResourceHeaderLinkError = (error) => {
+    if (isProtocolV2DeviceDisconnectedError(error))
+        return true;
+    const errorCode = getProtocolV2ErrorCode(error);
+    if (errorCode === hdShared.HardwareErrorCode.BleTimeoutError)
+        return true;
+    const message = getProtocolV2UnknownErrorText(error);
+    if (errorCode === hdShared.HardwareErrorCode.TransportNotFound && /not connected/i.test(message)) {
+        return true;
+    }
+    return (message.includes('ProtocolV2LinkError') ||
+        message.includes('Device protocol has not been detected') ||
+        message.includes('Electron BLE device state cleaned') ||
+        message.includes('Electron BLE transport released'));
+};
 const isProtocolV2TerminalInstallStatusError = (error) => {
     var _a;
     return error instanceof hdShared.HardwareError &&
@@ -52917,6 +52944,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         this.protocolV2InstallTerminalSuccessObserved = false;
         this.protocolV2LastTransferProgressAt = 0;
         this.protocolV2LastTransferredBytes = 0;
+        this.protocolV2FileWriteWindowDisabled = false;
     }
     getSupportedProtocols() {
         return ['V2'];
@@ -53063,7 +53091,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             componentArtifacts: preparedPlan ? undefined : payload.componentArtifacts,
         };
     }
-    getProtocolV2FirmwareChunkSize(direction, filePath) {
+    getProtocolV2FirmwareChunkSize(direction, filePath, fileWriteWindow = false) {
         var _a, _b;
         const payloadChunkSize = Number((_a = this.params) === null || _a === void 0 ? void 0 : _a.chunkSize);
         const env = DataManager.getSettings('env');
@@ -53073,6 +53101,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (direction === 'read') {
                 maxChunkSize = hdTransport.PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
             }
+            else if (fileWriteWindow) {
+                maxChunkSize = hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+            }
             else {
                 maxChunkSize = PROTOCOL_V2_FIRMWARE_STAGING_PATHS.has(filePath !== null && filePath !== void 0 ? filePath : '')
                     ? hdTransport.PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE
@@ -53887,11 +53918,33 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 return true;
             }
             catch (error) {
+                if (isProtocolV2ResourceHeaderLinkError(error))
+                    throw error;
                 Log$6.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
                 return false;
             }
         });
     }
+    isProtocolV2ResourceBundleUpToDateWithRecovery(bundle, recovery) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (;;) {
+                try {
+                    return yield this.isProtocolV2ResourceBundleUpToDate(bundle);
+                }
+                catch (error) {
+                    this.throwIfAborted();
+                    if (recovery.remaining <= 0) {
+                        Log$6.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check lost the link; reconnect budget used up: `, getProtocolV2UnknownErrorText(error));
+                        return false;
+                    }
+                    recovery.remaining -= 1;
+                    Log$6.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check lost the link; reconnecting: `, getProtocolV2UnknownErrorText(error));
+                }
+                yield this.recoverProtocolV2FileTransfer();
+                this.throwIfAborted();
+            }
+        });
+    }
     isProtocolV2BootloaderMode() {
         var _a, _b, _c;
         if (typeof this.device.isBootloader === 'function') {
@@ -54070,8 +54123,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
             const resourcesToSync = [];
+            const headerRecovery = { remaining: PROTOCOL_V2_RESOURCE_HEADER_RECOVERY_LIMIT };
             for (const resource of resourceSources) {
-                if (yield this.isProtocolV2ResourceBundleUpToDate(resource)) {
+                if (yield this.isProtocolV2ResourceBundleUpToDateWithRecovery(resource, headerRecovery)) {
                     Log$6.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
                 }
                 else {
@@ -54116,13 +54170,20 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 });
             }
             if (totalSize > 0) {
-                const elapsedMs = Math.max(Date.now() - transferStartedAt, 0);
+                const elapsedMs = getProtocolV2ElapsedMs(transferStartedAt);
+                const rateBytesPerSecond = getProtocolV2TransferRate(totalSize, elapsedMs);
                 this.postProgressMessage(100, 'transferData', {
                     transferredBytes: totalSize,
                     totalBytes: totalSize,
-                    rateBytesPerSecond: elapsedMs > 0 ? Math.round((totalSize / elapsedMs) * 1000) : undefined,
+                    rateBytesPerSecond,
                     elapsedMs,
                 });
+                Log$6.debug('[FirmwareUpdateV4] Protocol V2 transfer completed', {
+                    files: resourcesToSync.length + installSources.length,
+                    totalBytes: totalSize,
+                    elapsedMs,
+                    rateBytesPerSecond,
+                });
             }
             if (stagedInstallTargets.length === 0) {
                 return;
@@ -54132,10 +54193,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 target_id: item.targetId,
                 path: item.path,
             }));
+            const installStartedAt = Date.now();
             try {
                 yield this.protocolV2StartFirmwareUpdate({ targets });
                 yield hdShared.wait(PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY);
                 yield this.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+                Log$6.debug('[FirmwareUpdateV4] Protocol V2 install completed', {
+                    targets: targets.length,
+                    elapsedMs: getProtocolV2ElapsedMs(installStartedAt),
+                });
             }
             finally {
                 (_a = this.device) === null || _a === void 0 ? void 0 : _a.clearCancelableAction();
@@ -54144,51 +54210,84 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     protocolV2SourceUpdateProcess({ source, filePath, processedSize, totalSize, transferStartedAt = Date.now(), }) {
         return __awaiter(this, void 0, void 0, function* () {
+            const reportConfirmedChunk = (chunkEnd) => {
+                const transferredBytes = processedSize + chunkEnd;
+                const now = Date.now();
+                const elapsedMs = getProtocolV2ElapsedMs(transferStartedAt, now);
+                const progress = Math.min(Math.ceil((transferredBytes / totalSize) * 100), 99);
+                const shouldPostProgress = transferredBytes >= this.protocolV2LastTransferredBytes &&
+                    (progress !== this.protocolV2LastTransferProgress ||
+                        now - this.protocolV2LastTransferProgressAt >=
+                            PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS ||
+                        chunkEnd === source.size);
+                if (shouldPostProgress) {
+                    this.protocolV2LastTransferProgress = progress;
+                    this.protocolV2LastTransferProgressAt = now;
+                    this.protocolV2LastTransferredBytes = transferredBytes;
+                    this.postProgressMessage(progress, 'transferData', {
+                        transferredBytes,
+                        totalBytes: totalSize,
+                        rateBytesPerSecond: getProtocolV2TransferRate(transferredBytes, elapsedMs),
+                        elapsedMs,
+                    });
+                }
+            };
             let lastError;
             for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
                 this.throwIfAborted();
+                const attemptStartedAt = Date.now();
+                let windowed = false;
                 try {
-                    yield writeFirmwareByteSource({
-                        source,
-                        chunkSize: this.getProtocolV2FirmwareChunkSize('write', filePath),
-                        write: ({ data, sourceOffset, length, first }) => __awaiter(this, void 0, void 0, function* () {
-                            this.throwIfAborted();
-                            const chunkEnd = sourceOffset + length;
-                            const deviceProgress = getProtocolV2DeviceTransferProgress(processedSize + sourceOffset, processedSize + chunkEnd, totalSize);
-                            const response = yield this.fileWriteChunk(filePath, source.size, sourceOffset, data, first, deviceProgress);
-                            const rawProcessedByte = response.message.processed_byte;
-                            const nextOffset = rawProcessedByte === undefined ? chunkEnd : Number(rawProcessedByte);
-                            if (!Number.isFinite(nextOffset) || nextOffset !== chunkEnd) {
-                                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${rawProcessedByte} for offset ${sourceOffset}`);
-                            }
-                            const transferredBytes = processedSize + chunkEnd;
-                            const now = Date.now();
-                            const elapsedMs = Math.max(now - transferStartedAt, 0);
-                            const progress = Math.min(Math.ceil((transferredBytes / totalSize) * 100), 99);
-                            const shouldPostProgress = transferredBytes >= this.protocolV2LastTransferredBytes &&
-                                (progress !== this.protocolV2LastTransferProgress ||
-                                    now - this.protocolV2LastTransferProgressAt >=
-                                        PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS ||
-                                    chunkEnd === source.size);
-                            if (shouldPostProgress) {
-                                this.protocolV2LastTransferProgress = progress;
-                                this.protocolV2LastTransferProgressAt = now;
-                                this.protocolV2LastTransferredBytes = transferredBytes;
-                                this.postProgressMessage(progress, 'transferData', {
-                                    transferredBytes,
-                                    totalBytes: totalSize,
-                                    rateBytesPerSecond: elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
-                                    elapsedMs,
-                                });
-                            }
-                            return length;
-                        }),
+                    windowed =
+                        !this.protocolV2FileWriteWindowDisabled && this.shouldUseProtocolV2BleFileWriteWindow();
+                    const chunkSize = this.getProtocolV2FirmwareChunkSize('write', filePath, windowed);
+                    if (windowed) {
+                        yield this.writeProtocolV2SourceWindowed({
+                            source,
+                            filePath,
+                            chunkSize,
+                            processedSize,
+                            totalSize,
+                            onChunkConfirmed: reportConfirmedChunk,
+                        });
+                    }
+                    else {
+                        yield writeFirmwareByteSource({
+                            source,
+                            chunkSize,
+                            write: ({ data, sourceOffset, length, first }) => __awaiter(this, void 0, void 0, function* () {
+                                this.throwIfAborted();
+                                const chunkEnd = sourceOffset + length;
+                                const deviceProgress = getProtocolV2DeviceTransferProgress(processedSize + sourceOffset, processedSize + chunkEnd, totalSize);
+                                const response = yield this.fileWriteChunk(filePath, source.size, sourceOffset, data, first, deviceProgress);
+                                const rawProcessedByte = response.message.processed_byte;
+                                const nextOffset = rawProcessedByte === undefined ? chunkEnd : Number(rawProcessedByte);
+                                if (!Number.isFinite(nextOffset) || nextOffset !== chunkEnd) {
+                                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${rawProcessedByte} for offset ${sourceOffset}`);
+                                }
+                                reportConfirmedChunk(chunkEnd);
+                                return length;
+                            }),
+                        });
+                    }
+                    Log$6.debug('[FirmwareUpdateV4] Protocol V2 file transferred', {
+                        path: filePath,
+                        bytes: source.size,
+                        elapsedMs: getProtocolV2ElapsedMs(attemptStartedAt),
+                        attempt,
+                        fileWriteWindow: windowed ? hdTransport.PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW : 1,
                     });
                     return processedSize + source.size;
                 }
                 catch (error) {
                     this.throwIfAborted();
                     lastError = error;
+                    Log$6.debug('[FirmwareUpdateV4] Protocol V2 file transfer attempt failed', {
+                        path: filePath,
+                        attempt,
+                        fileWriteWindow: windowed ? hdTransport.PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW : 1,
+                        error: getProtocolV2UnknownErrorText(error),
+                    });
                     if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
                         yield this.recoverProtocolV2FileTransfer();
                         this.throwIfAborted();
@@ -54871,16 +54970,96 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return writeRes;
         });
     }
+    shouldUseProtocolV2BleFileWriteWindow(minBootloaderVersion = PROTOCOL_V2_BLE_FILE_WRITE_WINDOW_MIN_BOOTLOADER_VERSION) {
+        var _a, _b;
+        const env = DataManager.getSettings('env');
+        if ((env !== 'react-native' && env !== 'desktop-web-ble') ||
+            !this.isProtocolV2BootloaderMode()) {
+            return false;
+        }
+        const bootloaderVersion = getDeviceBootloaderVersion(this.device.features).join('.');
+        const enabled = supportsProtocolV2BleFileWriteWindow(bootloaderVersion, minBootloaderVersion);
+        Log$6.debug('[FirmwareUpdateV4] BLE FileWrite window', {
+            enabled,
+            bootloaderVersion,
+            bootloaderBuildId: (_b = (_a = this.device.features) === null || _a === void 0 ? void 0 : _a.verify) === null || _b === void 0 ? void 0 : _b.bootloaderBuildId,
+        });
+        return enabled;
+    }
+    writeProtocolV2SourceWindowed({ source, filePath, chunkSize, processedSize, totalSize, onChunkConfirmed, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let sendOffset = 0;
+            let sourceError;
+            const readRequest = () => __awaiter(this, void 0, void 0, function* () {
+                const offset = sendOffset;
+                const length = Math.min(chunkSize, source.size - offset);
+                const data = yield source.readAt(offset, length);
+                sendOffset += length;
+                return {
+                    file: { path: filePath, offset, total_size: source.size, data },
+                    overwrite: offset === 0,
+                    append: false,
+                    ui_percentage: getProtocolV2DeviceTransferProgress(processedSize + offset, processedSize + sendOffset, totalSize),
+                };
+            });
+            const nextRequest = () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (((_a = this.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) || sendOffset >= source.size)
+                    return undefined;
+                try {
+                    return yield readRequest();
+                }
+                catch (error) {
+                    sourceError = error;
+                    return undefined;
+                }
+            });
+            this.throwIfAborted();
+            if (source.size === 0)
+                return;
+            const firstRequest = yield readRequest();
+            const response = yield this.device
+                .getCommands()
+                .typedCall('FilesystemFileWrite', 'FilesystemFile', firstRequest, {
+                timeoutMs: PROTOCOL_V2_FILE_WRITE_RESPONSE_TIMEOUT,
+                writeWithResponse: false,
+                fileWritePipeline: {
+                    next: nextRequest,
+                    onResponse: confirmed => {
+                        onChunkConfirmed(Number(confirmed.message.processed_byte));
+                    },
+                },
+            })
+                .catch((error) => {
+                this.protocolV2FileWriteWindowDisabled = true;
+                throw error;
+            });
+            this.throwIfAborted();
+            if (sourceError)
+                throw sourceError;
+            const rawProcessedByte = response.message.processed_byte;
+            if (Number(rawProcessedByte) !== source.size) {
+                this.protocolV2FileWriteWindowDisabled = true;
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${rawProcessedByte} for file size ${source.size}`);
+            }
+        });
+    }
     recoverProtocolV2FileTransfer() {
         return __awaiter(this, void 0, void 0, function* () {
-            const env = DataManager.getSettings('env');
-            if (DataManager.isBleConnect(env)) {
-                yield hdShared.wait(3000);
+            try {
+                const env = DataManager.getSettings('env');
+                if (DataManager.isBleConnect(env)) {
+                    yield hdShared.wait(3000);
+                }
+                yield this.reconnectProtocolV2Device();
+                yield this.verifyProtocolV2ReconnectIdentity();
+                yield this.device.initialize();
+                yield hdShared.wait(2000);
+            }
+            catch (error) {
+                this.throwIfAborted();
+                throw error;
             }
-            yield this.reconnectProtocolV2Device();
-            yield this.verifyProtocolV2ReconnectIdentity();
-            yield this.device.initialize();
-            yield hdShared.wait(2000);
         });
     }
     acquireProtocolV2BleDevice(skipProtocolProbe = false) {

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

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAMF,cAAM,GAAG;IACP,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,EAAE,OAAO,CAAC;IAEjB,QAAQ,EAAE,UAAU,EAAE,CAAC;gBAEX,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAM5C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAYxD,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IASlB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IASpB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IASnB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;CAQrB;AAID,eAAO,MAAM,OAAO,WAAY,MAAM,YAAY,OAAO,QAIxD,CAAC;AAEF,eAAO,MAAM,SAAS,aAAc,OAAO,SAI1C,CAAC;AAEF,eAAO,MAAM,iBAAiB,WAAY,MAAM,WAAW,OAAO,SAIjE,CAAC;AAEF,eAAO,MAAM,MAAM,oBAOlB,CAAC;AAEF,eAAO,MAAM,oBAAoB,4BAA6B,WAAW,KAAK,IAAI,SAEjF,CAAC;AAuCF,oBAAY,WAAW;IACrB,IAAI,oBAAoB;IACxB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,cAAc,mBAAmB;IACjC,eAAe,oBAAoB;IACnC,UAAU,eAAe;IACzB,UAAU,eAAe;IACzB,kBAAkB,+BAA+B;IACjD,QAAQ,uBAAuB;IAC/B,eAAe,8BAA8B;IAC7C,mBAAmB,kCAAkC;IACrD,cAAc,6BAA6B;IAC3C,iBAAiB,iCAAiC;IAClD,iBAAiB,gCAAgC;IACjD,kBAAkB,kCAAkC;IACpD,OAAO,oBAAoB;IAC3B,MAAM,WAAW;IACjB,WAAW,kBAAkB;IAC7B,MAAM,aAAa;CACpB;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;CAoBrB,CAAC;AAEF,eAAO,MAAM,SAAS,QAAS,WAAW,QAAmB,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAMF,cAAM,GAAG;IACP,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,EAAE,OAAO,CAAC;IAEjB,QAAQ,EAAE,UAAU,EAAE,CAAC;gBAEX,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAM5C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAYxD,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IASlB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IASpB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IASnB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;CAQrB;AAID,eAAO,MAAM,OAAO,WAAY,MAAM,YAAY,OAAO,QAQxD,CAAC;AAEF,eAAO,MAAM,SAAS,aAAc,OAAO,SAI1C,CAAC;AAEF,eAAO,MAAM,iBAAiB,WAAY,MAAM,WAAW,OAAO,SAIjE,CAAC;AAEF,eAAO,MAAM,MAAM,oBAOlB,CAAC;AAEF,eAAO,MAAM,oBAAoB,4BAA6B,WAAW,KAAK,IAAI,SAEjF,CAAC;AAuCF,oBAAY,WAAW;IACrB,IAAI,oBAAoB;IACxB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,cAAc,mBAAmB;IACjC,eAAe,oBAAoB;IACnC,UAAU,eAAe;IACzB,UAAU,eAAe;IACzB,kBAAkB,+BAA+B;IACjD,QAAQ,uBAAuB;IAC/B,eAAe,8BAA8B;IAC7C,mBAAmB,kCAAkC;IACrD,cAAc,6BAA6B;IAC3C,iBAAiB,iCAAiC;IAClD,iBAAiB,gCAAgC;IACjD,kBAAkB,kCAAkC;IACpD,OAAO,oBAAoB;IAC3B,MAAM,WAAW;IACjB,WAAW,kBAAkB;IAC7B,MAAM,aAAa;CACpB;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;CAoBrB,CAAC;AAEF,eAAO,MAAM,SAAS,QAAS,WAAW,QAAmB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.8-alpha.119",
+  "version": "1.2.8-alpha.120",
   "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.2.8-alpha.119",
-    "@onekeyfe/hd-transport": "1.2.8-alpha.119",
+    "@onekeyfe/hd-shared": "1.2.8-alpha.120",
+    "@onekeyfe/hd-transport": "1.2.8-alpha.120",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "26953c0d533e9a05980abc8ea43e7bbd45ead861"
+  "gitHead": "55dea2982ecb17d1699b0226690b4ee3795e97a6"
 }