@onekeyfe/hd-core 1.2.1-alpha.0 → 1.2.2-alpha.0

package/dist/index.js

@@ -42623,7 +42623,7 @@ function invalidParameter$2(message) {
 function asBytes(rgba) {
     return rgba instanceof Uint8Array ? rgba : new Uint8Array(rgba);
 }
-function align(value, boundary) {
+function align$1(value, boundary) {
     return Math.ceil(value / boundary) * boundary;
 }
 function encodePro2Image(options) {
@@ -42651,7 +42651,7 @@ function encodePro2Image(options) {
         }
     }
     const colorFormat = hasTransparency ? 'RGB565A8' : 'RGB565';
-    const stride = align(width * 2, 4);
+    const stride = align$1(width * 2, 4);
     const alphaStride = stride / 2;
     const rgbSize = stride * height;
     const alphaSize = hasTransparency ? alphaStride * height : 0;
@@ -52302,13 +52302,6 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error) => {
         message.includes('message handler not found') ||
         message.includes('unsupported message'));
 };
-const isProtocolV2InstallResponseTimeout = (error) => {
-    if (!error || typeof error !== 'object')
-        return false;
-    const { code } = error;
-    return (code === 'response-timeout' ||
-        /\bresponse timeout\b/i.test(getProtocolV2UnknownErrorText(error)));
-};
 const isProtocolV2TerminalInstallStatusError = (error) => {
     var _a;
     return hdShared.isBleStaleBondHardwareError(error) ||
@@ -52436,7 +52429,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         this.protocolV2CompletedTargetIds = new Set();
         this.protocolV2InstallBaselineVersions = new Map();
         this.protocolV2InstallNeedsReconnect = false;
-        this.protocolV2InstallDisconnectObserved = false;
         this.protocolV2InstallTerminalSuccessObserved = false;
         this.protocolV2LastTransferProgressAt = 0;
     }
@@ -53907,15 +53899,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             const expectedTargetIds = new Set(targets.map(target => target.target_id));
             const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
-            const isBleInstall = this.isBleReconnect();
+            const isBleCoprocessorInstall = this.isBleReconnect() &&
+                expectedTargetIds.has(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR);
             const startTime = Date.now();
             let lastError;
             let shouldReconnect = this.protocolV2InstallNeedsReconnect;
             this.protocolV2InstallNeedsReconnect = false;
             let deviceInfo;
             let bleInstallLinkReady = false;
-            let installStatusDisconnectObserved = isBleInstall && this.protocolV2InstallDisconnectObserved;
-            this.protocolV2InstallDisconnectObserved = false;
+            let installStatusDisconnectObserved = false;
             let installReconnectObserved = false;
             let finishedStatusSnapshotKey;
             let finishedStatusSnapshotPolls = 0;
@@ -53923,17 +53915,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
             let currentInstallStatusObserved = false;
             const liveTargetIds = new Set();
-            const recordBleInstallDisconnect = (error) => {
-                if (!isBleInstall ||
-                    !isProtocolV2DeviceDisconnectedError(error) ||
-                    isProtocolV2InstallResponseTimeout(error)) {
-                    return;
-                }
-                installStatusDisconnectObserved = true;
-                installReconnectObserved = false;
-                finishedStatusSnapshotKey = undefined;
-                finishedStatusSnapshotPolls = 0;
-            };
             while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
                 this.throwIfAborted();
                 try {
@@ -54120,7 +54101,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             }
                         }
                         else {
-                            recordBleInstallDisconnect(error);
+                            if (isBleCoprocessorInstall &&
+                                isProtocolV2DeviceDisconnectedError(error) &&
+                                !isProtocolV2ResponseTimeout(error)) {
+                                installStatusDisconnectObserved = true;
+                                finishedStatusSnapshotKey = undefined;
+                                finishedStatusSnapshotPolls = 0;
+                            }
                             shouldReconnect = true;
                             deviceInfo = undefined;
                             bleInstallLinkReady = false;
@@ -54141,7 +54128,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         ((_b = error.params) === null || _b === void 0 ? void 0 : _b.firmwareUpdateCode) === 'FirmwareInstallStatusUnavailable') {
                         throw error;
                     }
-                    recordBleInstallDisconnect(error);
                     shouldReconnect = true;
                     deviceInfo = undefined;
                     bleInstallLinkReady = false;
@@ -54391,7 +54377,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             this.protocolV2LastRuntimeProbeFeatures = undefined;
             this.protocolV2InstallNeedsReconnect = false;
-            this.protocolV2InstallDisconnectObserved = false;
             this.protocolV2InstallTerminalSuccessObserved = false;
             const commands = this.device.getCommands();
             yield commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
@@ -54419,7 +54404,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 }
                 Log$6.log('[FirmwareUpdateV4] transport released while writing install request; continue status polling');
                 this.protocolV2InstallNeedsReconnect = true;
-                this.protocolV2InstallDisconnectObserved = !isProtocolV2InstallResponseTimeout(error);
             }
         });
     }
@@ -54612,7 +54596,234 @@ function decodeJpegBase64ToRgba({ jpegBase64, parameterName, expectedWidth, expe
     return decoded;
 }
 
+const PRO2_HOST_ASSET_PACKAGE_MIN_VERSION = '1.0.1';
+const CONTAINER_HEADER_SIZE = 0x5f90;
+const CONTAINER_HEADER_HASH_INPUT_LENGTH = 0x240;
+const CONTAINER_HASH_SECTION_OFFSET = 0x200;
+const CONTAINER_SIGNATURE_ALGORITHM_OFFSET = 0x408;
+const CONTAINER_HEADER_MAGIC = 0x50504b4f;
+const CONTAINER_HEADER_VERSION = 1;
+const CONTAINER_RESOURCE_TYPE_MAGIC = 0x43534552;
+const CONTAINER_ED25519_SIGNATURE_ALGORITHM = 0x71717171;
+const ARCHIVE_MAGIC = 0x52414b4f;
+const ARCHIVE_VERSION = 1;
+const ARCHIVE_HEADER_SIZE = 42;
+const ARCHIVE_ENTRY_SIZE = 296;
+const ARCHIVE_ENTRY_NAME_MAX_LENGTH = 255;
+const ARCHIVE_COMPRESS_LZ4_BLOCKED = 1;
+const ARCHIVE_ALIGNMENT = 4;
+const LZ4_BLOCK_SIZE_LOG2 = 12;
+const LZ4_MIN_MATCH = 4;
+const LZ4_LAST_LITERALS = 5;
+const LZ4_MATCH_FIND_LIMIT = 12;
+const LZ4_MAX_OFFSET = 0xffff;
+const LZ4_LENGTH_MASK = 15;
+const LZ4_HASH_LOG = 16;
+const LZ4_HASH_MULTIPLIER = 2654435761;
+const LZ4_SKIP_TRIGGER = 6;
+const HOST_ASSET_PACKAGE_MAX_SIZE = 4 * 1024 * 1024;
+function supportsPro2HostAssetPackage(firmwareVersion) {
+    return Boolean(firmwareVersion &&
+        semver__default["default"].valid(firmwareVersion) &&
+        semver__default["default"].gte(firmwareVersion, PRO2_HOST_ASSET_PACKAGE_MIN_VERSION));
+}
+function align(value) {
+    return (value + ARCHIVE_ALIGNMENT - 1) & ~(ARCHIVE_ALIGNMENT - 1);
+}
+function concatBytes(parts) {
+    const output = new Uint8Array(parts.reduce((length, part) => length + part.byteLength, 0));
+    let offset = 0;
+    for (const part of parts) {
+        output.set(part, offset);
+        offset += part.byteLength;
+    }
+    return output;
+}
+function writeExtendedLength(output, offset, length) {
+    let remaining = length;
+    let nextOffset = offset;
+    while (remaining >= 255) {
+        output[nextOffset] = 255;
+        nextOffset += 1;
+        remaining -= 255;
+    }
+    output[nextOffset] = remaining;
+    return nextOffset + 1;
+}
+function copyBytes(output, outputOffset, input, inputOffset, length) {
+    output.set(input.subarray(inputOffset, inputOffset + length), outputOffset);
+    return outputOffset + length;
+}
+function emitSequence(output, outputOffset, input, anchor, literalLength, matchOffset, matchLengthCode) {
+    const tokenOffset = outputOffset;
+    let nextOffset = outputOffset + 1;
+    let token = 0;
+    if (literalLength >= LZ4_LENGTH_MASK) {
+        token = LZ4_LENGTH_MASK << 4;
+        nextOffset = writeExtendedLength(output, nextOffset, literalLength - LZ4_LENGTH_MASK);
+    }
+    else {
+        token = literalLength << 4;
+    }
+    nextOffset = copyBytes(output, nextOffset, input, anchor, literalLength);
+    output[nextOffset] = matchOffset & 0xff;
+    output[nextOffset + 1] = (matchOffset >>> 8) & 0xff;
+    nextOffset += 2;
+    if (matchLengthCode >= LZ4_LENGTH_MASK) {
+        token |= LZ4_LENGTH_MASK;
+        nextOffset = writeExtendedLength(output, nextOffset, matchLengthCode - LZ4_LENGTH_MASK);
+    }
+    else {
+        token |= matchLengthCode;
+    }
+    output[tokenOffset] = token;
+    return nextOffset;
+}
+function emitLastLiterals(output, outputOffset, input, anchor, literalLength) {
+    const tokenOffset = outputOffset;
+    let nextOffset = outputOffset + 1;
+    if (literalLength >= LZ4_LENGTH_MASK) {
+        output[tokenOffset] = LZ4_LENGTH_MASK << 4;
+        nextOffset = writeExtendedLength(output, nextOffset, literalLength - LZ4_LENGTH_MASK);
+    }
+    else {
+        output[tokenOffset] = literalLength << 4;
+    }
+    return copyBytes(output, nextOffset, input, anchor, literalLength);
+}
+function compressRawLz4Block(input, hashTable) {
+    const output = new Uint8Array(input.byteLength + Math.floor(input.byteLength / 255) + 16);
+    const inputView = new DataView(input.buffer, input.byteOffset, input.byteLength);
+    const matchFindLimit = input.byteLength - LZ4_MATCH_FIND_LIMIT;
+    const matchExtendLimit = input.byteLength - LZ4_LAST_LITERALS;
+    let anchor = 0;
+    let inputOffset = 0;
+    let outputOffset = 0;
+    let searchMatchCount = 1 << LZ4_SKIP_TRIGGER;
+    hashTable.fill(0);
+    while (inputOffset < matchFindLimit) {
+        const sequence = inputView.getUint32(inputOffset, true);
+        const hash = Math.imul(sequence, LZ4_HASH_MULTIPLIER) >>> (32 - LZ4_HASH_LOG);
+        const candidate = hashTable[hash] - 1;
+        hashTable[hash] = inputOffset + 1;
+        const hasMatch = !(candidate < 0 ||
+            inputOffset - candidate > LZ4_MAX_OFFSET ||
+            inputView.getUint32(candidate, true) !== sequence);
+        if (!hasMatch) {
+            inputOffset += searchMatchCount >> LZ4_SKIP_TRIGGER;
+            searchMatchCount += 1;
+        }
+        else {
+            searchMatchCount = 1 << LZ4_SKIP_TRIGGER;
+            let matchEnd = inputOffset + LZ4_MIN_MATCH;
+            let reference = candidate + LZ4_MIN_MATCH;
+            while (matchEnd < matchExtendLimit && input[matchEnd] === input[reference]) {
+                matchEnd += 1;
+                reference += 1;
+            }
+            outputOffset = emitSequence(output, outputOffset, input, anchor, inputOffset - anchor, inputOffset - candidate, matchEnd - inputOffset - LZ4_MIN_MATCH);
+            inputOffset = matchEnd;
+            anchor = inputOffset;
+        }
+    }
+    outputOffset = emitLastLiterals(output, outputOffset, input, anchor, input.byteLength - anchor);
+    return output.slice(0, outputOffset);
+}
+function encodeLz4Blocked(data) {
+    const blockSize = 1 << LZ4_BLOCK_SIZE_LOG2;
+    const blockCount = Math.ceil(data.byteLength / blockSize);
+    const hashTable = new Uint32Array(1 << LZ4_HASH_LOG);
+    const blocks = [];
+    const header = new Uint8Array(8 + blockCount * 4);
+    const headerView = new DataView(header.buffer);
+    headerView.setUint16(0, blockCount, true);
+    headerView.setUint16(2, LZ4_BLOCK_SIZE_LOG2, true);
+    for (let index = 0; index < blockCount; index += 1) {
+        const block = compressRawLz4Block(data.subarray(index * blockSize, Math.min((index + 1) * blockSize, data.byteLength)), hashTable);
+        headerView.setUint32(8 + index * 4, block.byteLength, true);
+        blocks.push(block);
+    }
+    return concatBytes([header, ...blocks]);
+}
+const CRC32_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let index = 0; index < table.length; index += 1) {
+        let value = index;
+        for (let bit = 0; bit < 8; bit += 1) {
+            value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+        }
+        table[index] = value >>> 0;
+    }
+    return table;
+})();
+function crc32(data) {
+    let value = 0xffffffff;
+    for (const byte of data) {
+        value = CRC32_TABLE[(value ^ byte) & 0xff] ^ (value >>> 8);
+    }
+    return (value ^ 0xffffffff) >>> 0;
+}
+function buildArchive(entries) {
+    const textEncoder = new TextEncoder();
+    let dataOffset = ARCHIVE_HEADER_SIZE + entries.length * ARCHIVE_ENTRY_SIZE;
+    const encodedEntries = entries.map(entry => {
+        const nameBytes = textEncoder.encode(entry.name);
+        if (!entry.name || nameBytes.byteLength > ARCHIVE_ENTRY_NAME_MAX_LENGTH) {
+            throw new Error('Pro2 host asset package entry names must contain 1 to 255 UTF-8 bytes.');
+        }
+        if (!(entry.data instanceof Uint8Array) || entry.data.byteLength === 0) {
+            throw new Error(`Pro2 host asset package entry [${entry.name}] must not be empty.`);
+        }
+        const compressed = encodeLz4Blocked(entry.data);
+        const offset = align(dataOffset);
+        dataOffset = offset + compressed.byteLength;
+        return Object.assign(Object.assign({}, entry), { nameBytes, compressed, offset });
+    });
+    const archive = new Uint8Array(dataOffset);
+    const view = new DataView(archive.buffer);
+    view.setUint32(0, ARCHIVE_MAGIC, true);
+    view.setUint32(4, ARCHIVE_VERSION, true);
+    view.setUint16(8, encodedEntries.length, true);
+    encodedEntries.forEach((entry, index) => {
+        const recordOffset = ARCHIVE_HEADER_SIZE + index * ARCHIVE_ENTRY_SIZE;
+        archive[recordOffset] = entry.nameBytes.byteLength;
+        archive.set(entry.nameBytes, recordOffset + 1);
+        view.setUint32(recordOffset + 0x100, entry.offset, true);
+        view.setUint32(recordOffset + 0x104, entry.data.byteLength, true);
+        view.setUint32(recordOffset + 0x108, entry.compressed.byteLength, true);
+        view.setUint32(recordOffset + 0x10c, crc32(entry.data), true);
+        view.setUint32(recordOffset + 0x110, crc32(entry.compressed), true);
+        archive[recordOffset + 0x114] = ARCHIVE_COMPRESS_LZ4_BLOCKED;
+        archive.set(entry.compressed, entry.offset);
+    });
+    return archive;
+}
+function buildPro2HostAssetPackage(entries) {
+    if (entries.length === 0 || new Set(entries.map(entry => entry.name)).size !== entries.length) {
+        throw new Error('Pro2 host asset package entries must have unique, non-empty names.');
+    }
+    const payload = buildArchive(entries);
+    const header = new Uint8Array(CONTAINER_HEADER_SIZE);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, CONTAINER_HEADER_MAGIC, true);
+    view.setUint32(4, CONTAINER_HEADER_VERSION, true);
+    view.setUint32(8, CONTAINER_RESOURCE_TYPE_MAGIC, true);
+    view.setUint32(0x0c, CONTAINER_HEADER_SIZE, true);
+    view.setUint32(0x10, 1, true);
+    view.setUint32(0x14, payload.byteLength, true);
+    header.set(sha3.sha3_512(payload), CONTAINER_HASH_SECTION_OFFSET);
+    header.set(sha3.sha3_512(header.subarray(0, CONTAINER_HEADER_HASH_INPUT_LENGTH)), 0x240);
+    view.setUint32(CONTAINER_SIGNATURE_ALGORITHM_OFFSET, CONTAINER_ED25519_SIGNATURE_ALGORITHM, true);
+    const packageData = concatBytes([header, payload]);
+    if (packageData.byteLength > HOST_ASSET_PACKAGE_MAX_SIZE) {
+        throw new Error('Pro2 host asset package exceeds the firmware 4 MiB limit.');
+    }
+    return packageData;
+}
+
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
+const WALLPAPER_PACKAGE_PATH = `${WALLPAPER_DIRECTORY}/wallpaper.okpkg`;
+const WALLPAPER_PACKAGE_ENTRY = 'wallpaper.bin';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$2 = 60805;
@@ -54688,18 +54899,15 @@ class DeviceUploadWallpaper extends BaseMethod {
             this.directoryReady = true;
         });
     }
-    upload() {
+    upload(path, data) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.uploaded)
                 return;
-            const { encoded } = this;
-            if (!encoded)
-                throw invalidParameter$1('Wallpaper data has not been initialized.');
             yield writeProtocolV2File({
                 commands: this.device.commands,
-                path: this.path,
-                data: encoded.data,
-                totalSize: encoded.data.byteLength,
+                path,
+                data,
+                totalSize: data.byteLength,
                 chunkSize: this.params.chunkSize,
                 maxChunkRetries: 3,
                 overwrite: true,
@@ -54722,7 +54930,13 @@ class DeviceUploadWallpaper extends BaseMethod {
                 throw invalidParameter$1('Wallpaper data has not been initialized.');
             yield this.assertCapabilities();
             yield this.ensureDirectory();
-            yield this.upload();
+            const useHostAssetPackage = supportsPro2HostAssetPackage(this.device.getCurrentFirmwareVersionString());
+            const data = useHostAssetPackage
+                ? buildPro2HostAssetPackage([{ name: WALLPAPER_PACKAGE_ENTRY, data: encoded.data }])
+                : encoded.data;
+            if (useHostAssetPackage)
+                this.path = WALLPAPER_PACKAGE_PATH;
+            yield this.upload(this.path, data);
             const response = yield this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
                 settings: { wallpaper_path: this.path },
             });
@@ -54736,7 +54950,7 @@ class DeviceUploadWallpaper extends BaseMethod {
             }
             return {
                 path: this.path,
-                size: encoded.data.byteLength,
+                size: data.byteLength,
                 colorFormat: encoded.colorFormat,
                 message: (_a = response.message) === null || _a === void 0 ? void 0 : _a.message,
             };
@@ -54815,14 +55029,14 @@ class DeviceUploadNft extends BaseMethod {
         this.skipForceUpdateCheck = true;
         this.useDevicePassphraseState = false;
     }
-    assertCapabilities() {
+    assertCapabilities(useHostAssetPackage) {
         return __awaiter(this, void 0, void 0, function* () {
             const protocolInfo = yield this.device.ensureProtocolV2RuntimeContext();
             const hasFileWrite = supportsProtocolV2Message(protocolInfo, FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$1);
             const hasPathInfo = supportsProtocolV2Message(protocolInfo, FILESYSTEM_PATH_INFO_QUERY_MESSAGE_TYPE);
             const hasDirList = supportsProtocolV2Message(protocolInfo, FILESYSTEM_DIR_LIST_MESSAGE_TYPE);
             const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
-            if (!hasFileWrite || !hasPathInfo || !hasDirList || !hasNftUpdate) {
+            if (!hasFileWrite || !hasNftUpdate || (!useHostAssetPackage && (!hasPathInfo || !hasDirList))) {
                 throw hdShared.createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
             }
         });
@@ -54853,15 +55067,28 @@ class DeviceUploadNft extends BaseMethod {
             const { bundle } = this;
             if (!bundle)
                 throw invalidParameter$1('NFT data has not been initialized.');
-            yield this.assertCapabilities();
+            const useHostAssetPackage = supportsPro2HostAssetPackage(this.device.getCurrentFirmwareVersionString());
+            yield this.assertCapabilities(useHostAssetPackage);
             this.throwIfAborted();
-            yield this.assertStorageCapacity(bundle.basename);
+            if (!useHostAssetPackage)
+                yield this.assertStorageCapacity(bundle.basename);
             this.throwIfAborted();
-            const files = [
+            const extractedFiles = [
                 { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
                 { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
                 { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
             ];
+            const files = useHostAssetPackage
+                ? [
+                    {
+                        path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.okpkg`,
+                        data: buildPro2HostAssetPackage(extractedFiles.map(file => ({
+                            name: file.path.slice(`${PRO2_NFT_DIRECTORY}/`.length),
+                            data: file.data,
+                        }))),
+                    },
+                ]
+                : extractedFiles;
             const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
             let transferredBeforeFile = 0;
             for (const file of files) {
@@ -54890,9 +55117,9 @@ class DeviceUploadNft extends BaseMethod {
             const response = yield this.updateNft(bundle.basename);
             return {
                 basename: bundle.basename,
-                imagePath: files[0].path,
-                thumbnailPath: files[1].path,
-                metadataPath: files[2].path,
+                imagePath: extractedFiles[0].path,
+                thumbnailPath: extractedFiles[1].path,
+                metadataPath: extractedFiles[2].path,
                 totalSize,
                 nftUpdated: true,
                 message: (_a = response.message) === null || _a === void 0 ? void 0 : _a.message,
@@ -58187,6 +58414,7 @@ class EVMSignTypedData extends BaseMethod {
         const currentDeviceType = this.device.getCurrentDeviceType();
         const supportBiggerDataVersion = '4.4.0';
         const supportBiggerData = DeviceModelToTypes.model_classic1s.includes(currentDeviceType) ||
+            DeviceModelToTypes.model_pro2.includes(currentDeviceType) ||
             (DeviceModelToTypes.model_touch.includes(currentDeviceType) &&
                 semver__default["default"].gte(currentVersion, supportBiggerDataVersion));
         if (supportBiggerData) {

package/dist/utils/pro2HostAssetPackage.d.ts

@@ -0,0 +1,8 @@
+export declare const PRO2_HOST_ASSET_PACKAGE_MIN_VERSION = "1.0.1";
+export type Pro2HostAssetPackageEntry = {
+    name: string;
+    data: Uint8Array;
+};
+export declare function supportsPro2HostAssetPackage(firmwareVersion: string | undefined): boolean;
+export declare function buildPro2HostAssetPackage(entries: Pro2HostAssetPackageEntry[]): Uint8Array;
+//# sourceMappingURL=pro2HostAssetPackage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pro2HostAssetPackage.d.ts","sourceRoot":"","sources":["../../src/utils/pro2HostAssetPackage.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,mCAAmC,UAAU,CAAC;AA4B3D,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAQF,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAMzF;AA6ND,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,yBAAyB,EAAE,GAAG,UAAU,CAuB1F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.1-alpha.0",
+  "version": "1.2.2-alpha.0",
   "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.1-alpha.0",
-    "@onekeyfe/hd-transport": "1.2.1-alpha.0",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.0",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.0",
     "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": "9fb55052afede67ed054f2c42df96f93e24b5c49"
+  "gitHead": "9c18d7073728621179d58252e07fb3385b865226"
 }

package/src/api/FirmwareUpdateV4.ts

@@ -374,15 +374,6 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   );
 };
 
-const isProtocolV2InstallResponseTimeout = (error: unknown) => {
-  if (!error || typeof error !== 'object') return false;
-  const { code } = error as { code?: number | string };
-  return (
-    code === 'response-timeout' ||
-    /\bresponse timeout\b/i.test(getProtocolV2UnknownErrorText(error))
-  );
-};
-
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
   isBleStaleBondHardwareError(error) ||
   (error instanceof HardwareError &&
@@ -574,8 +565,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2InstallNeedsReconnect = false;
 
-  private protocolV2InstallDisconnectObserved = false;
-
   private protocolV2InstallTerminalSuccessObserved = false;
 
   private protocolV2LastRuntimeProbeFeatures?: Features;
@@ -2528,7 +2517,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
-    const isBleInstall = this.isBleReconnect();
+    const isBleCoprocessorInstall =
+      this.isBleReconnect() &&
+      expectedTargetIds.has(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR);
     const startTime = Date.now();
     let lastError: unknown;
     // The loader may release either USB or BLE as installation starts. Recovery reconnects
@@ -2537,8 +2528,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.protocolV2InstallNeedsReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
     let bleInstallLinkReady = false;
-    let installStatusDisconnectObserved = isBleInstall && this.protocolV2InstallDisconnectObserved;
-    this.protocolV2InstallDisconnectObserved = false;
+    let installStatusDisconnectObserved = false;
     let installReconnectObserved = false;
     let finishedStatusSnapshotKey: string | undefined;
     let finishedStatusSnapshotPolls = 0;
@@ -2546,19 +2536,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
     let currentInstallStatusObserved = false;
     const liveTargetIds = new Set<number>();
-    const recordBleInstallDisconnect = (error: unknown) => {
-      if (
-        !isBleInstall ||
-        !isProtocolV2DeviceDisconnectedError(error) ||
-        isProtocolV2InstallResponseTimeout(error)
-      ) {
-        return;
-      }
-      installStatusDisconnectObserved = true;
-      installReconnectObserved = false;
-      finishedStatusSnapshotKey = undefined;
-      finishedStatusSnapshotPolls = 0;
-    };
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       // A transport release caused by an explicit workflow cancellation must not
@@ -2810,7 +2787,15 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               );
             }
           } else {
-            recordBleInstallDisconnect(error);
+            if (
+              isBleCoprocessorInstall &&
+              isProtocolV2DeviceDisconnectedError(error) &&
+              !isProtocolV2ResponseTimeout(error)
+            ) {
+              installStatusDisconnectObserved = true;
+              finishedStatusSnapshotKey = undefined;
+              finishedStatusSnapshotPolls = 0;
+            }
             shouldReconnect = true;
             deviceInfo = undefined;
             bleInstallLinkReady = false;
@@ -2835,7 +2820,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ) {
           throw error;
         }
-        recordBleInstallDisconnect(error);
         shouldReconnect = true;
         deviceInfo = undefined;
         bleInstallLinkReady = false;
@@ -3170,7 +3154,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }) {
     this.protocolV2LastRuntimeProbeFeatures = undefined;
     this.protocolV2InstallNeedsReconnect = false;
-    this.protocolV2InstallDisconnectObserved = false;
     this.protocolV2InstallTerminalSuccessObserved = false;
     const commands = this.device.getCommands();
     await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
@@ -3213,7 +3196,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         '[FirmwareUpdateV4] transport released while writing install request; continue status polling'
       );
       this.protocolV2InstallNeedsReconnect = true;
-      this.protocolV2InstallDisconnectObserved = !isProtocolV2InstallResponseTimeout(error);
     }
   }
 

package/src/api/evm/EVMSignTypedData.ts

@@ -360,6 +360,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     const supportBiggerData =
       DeviceModelToTypes.model_classic1s.includes(currentDeviceType) ||
+      DeviceModelToTypes.model_pro2.includes(currentDeviceType) ||
       (DeviceModelToTypes.model_touch.includes(currentDeviceType) &&
         semver.gte(currentVersion, supportBiggerDataVersion));