@onekeyfe/hd-core 1.2.0-alpha.57 → 1.2.0-alpha.59

package/src/device/DevicePool.ts

@@ -103,7 +103,7 @@ export class DevicePool extends EventEmitter {
       const device = this.devicesCache[connectId];
       if (device) {
         const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
-        if (exist) {
+        if (exist && !initOptions?.forceProtocolDetection) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
           await this._refreshRuntimeState(device, initOptions);
@@ -151,14 +151,23 @@ export class DevicePool extends EventEmitter {
     }
   }
 
-  static async _createDevice(descriptor: DeviceDescriptor, initOptions?: InitOptions) {
-    let device = this.getDeviceByPath(descriptor.path);
-    if (!device) {
-      device = Device.fromDescriptor(descriptor);
+  static async _createDevice(
+    descriptor: DeviceDescriptor,
+    initOptions?: InitOptions
+  ): Promise<Device> {
+    const cachedDevice = this.getDeviceByPath(descriptor.path);
+    const forceProtocolDetection = initOptions?.forceProtocolDetection === true;
+    const isNewDevice = !cachedDevice;
+    const device = cachedDevice ?? Device.fromDescriptor(descriptor);
+    if (isNewDevice || forceProtocolDetection) {
       device.deviceConnector = this.connector;
-      await device.connect(initOptions?.connectProtocol, {
-        forceProtocolDetection: initOptions?.forceProtocolDetection,
-      });
+      if (forceProtocolDetection && !isNewDevice) {
+        await device.acquire(initOptions?.connectProtocol, { forceProtocolDetection: true });
+      } else {
+        await device.connect(initOptions?.connectProtocol, {
+          forceProtocolDetection: initOptions?.forceProtocolDetection,
+        });
+      }
       try {
         await device.initialize(initOptions);
         if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -1,4 +1,4 @@
-import { EFirmwareType } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import {
   resolveDeviceBleFirmwareVersion,
@@ -386,7 +386,7 @@ export const buildProtocolV2FeaturesPayload = ({
     device_id: deviceId ?? undefined,
     session_id: cached?.sessionId ?? undefined,
     ble_name: bleName ?? undefined,
-    onekey_device_type: 'PRO2',
+    onekey_device_type: deviceType === EDeviceType.Unknown ? undefined : deviceType.toUpperCase(),
     passphrase_protection: passphraseProtection ?? undefined,
     bootloader_mode: bootloaderMode,
     passphraseState: cached?.passphraseState,

package/src/deviceProfile/protocolV2DeviceIdentity.ts

@@ -26,6 +26,9 @@ export const resolveProtocolV2DeviceIdentity = (
     case DeviceType.PRO2:
     case 'PRO2':
       return { deviceType: EDeviceType.Pro2, model: 'pro2' };
+    case DeviceType.NEO:
+    case 'NEO':
+      return { deviceType: EDeviceType.Neo, model: 'neo' };
     default:
       return { deviceType: EDeviceType.Unknown, model: null };
   }

package/src/index.ts

@@ -10,11 +10,6 @@ export type { LowLevelCoreApi, LowLevelInjectApi } from './lowLevelInject';
 export type { TopLevelInjectApi } from './topLevelInject';
 
 export { default as Core, init as initCore, switchTransport } from './core';
-export type { CoreOptions } from './core';
-export { factoryApiMethodExtension, testApiMethodExtension } from './api/methodExtension';
-export type { CoreMethodConstructor, CoreMethodExtension } from './api/methodExtension';
-export { FACTORY_API_METHOD_NAMES, TEST_API_METHOD_NAMES } from './api/extensionMethodNames';
-export { createFactoryApi, createTestApi } from './inject';
 
 export * from './constants';
 export * from './utils';

package/src/inject.ts

@@ -1,10 +1,8 @@
-import { FACTORY_API_METHOD_NAMES, TEST_API_METHOD_NAMES } from './api/extensionMethodNames';
-
 import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type { Unsuccessful } from './types';
 import type { EventEmitter } from 'events';
 import type { CallMethod } from './events';
-import type { CoreApi, FactoryApi, TestApi, TestApiMethods } from './types/api';
+import type { CoreApi } from './types/api';
 import type { AllNetworkAddress } from './types/api/allNetworkGetAddress';
 
 type CallbackFunction = (data?: any, error?: Unsuccessful) => void;
@@ -133,7 +131,10 @@ export const inject = ({
   return api;
 };
 
-type ApiControlMethodName =
+export const createCoreApi = (
+  call: CoreApi['call']
+): Omit<
+  CoreApi,
   | 'on'
   | 'off'
   | 'emit'
@@ -145,11 +146,8 @@ type ApiControlMethodName =
   | 'uiResponse'
   | 'cancel'
   | 'updateSettings'
-  | 'switchTransport';
-
-type InjectedApi<TApi> = Omit<TApi, ApiControlMethodName>;
-
-const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
+  | 'switchTransport'
+> => ({
   getLogs: () => call({ method: 'getLogs' }),
   clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**
@@ -217,16 +215,6 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
   deviceReboot: (connectId, params) => call({ ...params, connectId, method: 'deviceReboot' }),
   deviceGetOnboardingStatus: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
-  deviceProvisionFactoryInfo: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceProvisionFactoryInfo' }),
-  deviceReadFactoryInfo: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceReadFactoryInfo' }),
-  deviceWriteFactoryCertificate: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceWriteFactoryCertificate' }),
-  deviceReadFactoryCertificate: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceReadFactoryCertificate' }),
-  deviceSignFactoryChallenge: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSignFactoryChallenge' }),
   deviceUploadWallpaper: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceUploadWallpaper' }),
   deviceUploadNft: (connectId, params) => call({ ...params, connectId, method: 'deviceUploadNft' }),
@@ -297,19 +285,6 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
   evmVerifyMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'evmVerifyMessage' }),
 
-  evmGetAddressTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmGetAddressTrezor' }),
-  evmGetPublicKeyTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmGetPublicKeyTrezor' }),
-  evmSignMessageTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmSignMessageTrezor' }),
-  evmSignTransactionTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmSignTransactionTrezor' }),
-  evmSignTypedDataTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmSignTypedDataTrezor' }),
-  evmVerifyMessageTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmVerifyMessageTrezor' }),
-
   btcGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'btcGetAddress' }),
   btcGetPublicKey: (connectId, deviceId, params) =>
@@ -322,25 +297,6 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
     call({ ...params, connectId, deviceId, method: 'btcSignTransaction' }),
   btcVerifyMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'btcVerifyMessage' }),
-  btcGetOwnershipId: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'btcGetOwnershipId' }),
-  btcGetOwnershipProof: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'btcGetOwnershipProof' }),
-  btcAuthorizeCoinJoin: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'btcAuthorizeCoinJoin' }),
-
-  cryptoBatchGetPublickeys: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoBatchGetPublickeys' }),
-  cryptoCipherKeyValue: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoCipherKeyValue' }),
-  cryptoCosiCommit: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoCosiCommit' }),
-  cryptoCosiSign: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoCosiSign' }),
-  cryptoGetECDHSessionKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoGetECDHSessionKey' }),
-  cryptoSignIdentity: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoSignIdentity' }),
 
   starcoinGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'starcoinGetAddress' }),
@@ -357,8 +313,6 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
     call({ ...params, connectId, deviceId, method: 'nemGetAddress' }),
   nemSignTransaction: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'nemSignTransaction' }),
-  nemDecryptMessage: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'nemDecryptMessage' }),
 
   solGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'solGetAddress' }),
@@ -524,164 +478,8 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
   benfenSignMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'benfenSignMessage' }),
 
-  /**
-   * Test-only APIs.
-   */
-  tezosGetAddress: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'tezosGetAddress' }),
-  tezosGetPublicKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'tezosGetPublicKey' }),
-  tezosSignTx: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'tezosSignTx' }),
-
-  binanceGetAddress: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'binanceGetAddress' }),
-  binanceGetPublicKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'binanceGetPublicKey' }),
-  binanceSignTx: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'binanceSignTx' }),
-
-  moneroGetWatchKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'moneroGetWatchKey' }),
-  moneroGetAddress: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'moneroGetAddress' }),
-
-  eosGetPublicKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'eosGetPublicKey' }),
-  eosSignTx: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'eosSignTx' }),
-
-  webAuthnAddResidentCredential: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'webAuthnAddResidentCredential' }),
-  webAuthnListResidentCredentials: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'webAuthnListResidentCredentials' }),
-  webAuthnRemoveResidentCredential: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'webAuthnRemoveResidentCredential' }),
-
-  getPublicKeyMultiple: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'getPublicKeyMultiple' }),
-  listResDir: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'listResDir' }),
-  nftWriteData: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'nftWriteData' }),
-  nftWriteInfo: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'nftWriteInfo' }),
-  readSEPublicKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'readSEPublicKey' }),
-  resourceUpdate: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'resourceUpdate' }),
-
-  bixinBackupDevice: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'bixinBackupDevice' }),
-  bixinLoadDevice: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'bixinLoadDevice' }),
-  bixinMessageSE: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'bixinMessageSE' }),
-  bixinVerifyDeviceRequest: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'bixinVerifyDeviceRequest' }),
-
-  deviceSpiFlashWrite: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSpiFlashWrite' }),
-  deviceSpiFlashRead: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSpiFlashRead' }),
-  deviceInfoSettings: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceInfoSettings' }),
-  deviceGetInfo: (connectId, params) => call({ ...params, connectId, method: 'deviceGetInfo' }),
-  deviceReadSEPublicCert: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceReadSEPublicCert' }),
-  deviceWriteSEPrivateKey: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceWriteSEPrivateKey' }),
-  deviceWriteSEPublicCert: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceWriteSEPublicCert' }),
-  deviceSESignMessage: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSESignMessage' }),
-  deviceGetFirmwareHash: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceGetFirmwareHash' }),
-  deviceUnlockPath: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceUnlockPath' }),
-  devicePing: (connectId, params) => call({ ...params, connectId, method: 'devicePing' }),
-  deviceGetEntropy: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceGetEntropy' }),
-  deviceSdProtect: (connectId, params) => call({ ...params, connectId, method: 'deviceSdProtect' }),
-  deviceChangeWipeCode: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceChangeWipeCode' }),
-  deviceEndSession: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceEndSession' }),
-  deviceLoad: (connectId, params) => call({ ...params, connectId, method: 'deviceLoad' }),
-  deviceDoPreauthorized: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceDoPreauthorized' }),
-  deviceCancelAuthorization: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceCancelAuthorization' }),
-
-  emmcDirList: (connectId, params) => call({ ...params, connectId, method: 'emmcDirList' }),
-  emmcDirMake: (connectId, params) => call({ ...params, connectId, method: 'emmcDirMake' }),
-  emmcDirRemove: (connectId, params) => call({ ...params, connectId, method: 'emmcDirRemove' }),
-  emmcFileDelete: (connectId, params) => call({ ...params, connectId, method: 'emmcFileDelete' }),
-  emmcFileRead: (connectId, params) => call({ ...params, connectId, method: 'emmcFileRead' }),
-  emmcFileWrite: (connectId, params) => call({ ...params, connectId, method: 'emmcFileWrite' }),
-  emmcFixPermission: (connectId, params) =>
-    call({ ...params, connectId, method: 'emmcFixPermission' }),
-  emmcPathInfo: (connectId, params) => call({ ...params, connectId, method: 'emmcPathInfo' }),
-
-  debugLinkDecision: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkDecision' }),
-  debugLinkEraseSdCard: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkEraseSdCard' }),
-  debugLinkFlashErase: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkFlashErase' }),
-  debugLinkGetState: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkGetState' }),
-  debugLinkMemoryRead: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkMemoryRead' }),
-  debugLinkMemoryWrite: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkMemoryWrite' }),
-  debugLinkRecordScreen: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkRecordScreen' }),
-  debugLinkReseedRandom: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkReseedRandom' }),
-  debugLinkStop: (connectId, params) => call({ ...params, connectId, method: 'debugLinkStop' }),
-  debugLinkWatchLayout: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkWatchLayout' }),
-
-  firmwareEraseEx: (connectId, params) => call({ ...params, connectId, method: 'firmwareEraseEx' }),
-  firmwareErase: (connectId, params) => call({ ...params, connectId, method: 'firmwareErase' }),
-  firmwareUpdateEmmcTest: (connectId, params) =>
-    call({ ...params, connectId, method: 'firmwareUpdateEmmcTest' }),
-  firmwareUploadTest: (connectId, params) =>
-    call({ ...params, connectId, method: 'firmwareUploadTest' }),
-  reboot: (connectId, params) => call({ ...params, connectId, method: 'reboot' }),
-  selfTest: (connectId, params) => call({ ...params, connectId, method: 'selfTest' }),
-
   neoGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'neoGetAddress' }),
   neoSignTransaction: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'neoSignTransaction' }),
 });
-
-const pickApiMethods = <TApi extends object>(
-  api: InjectedApi<TestApi>,
-  methodNames: readonly string[]
-): TApi => {
-  const selected: Record<string, unknown> = {};
-  methodNames.forEach(methodName => {
-    selected[methodName] = api[methodName as keyof typeof api];
-  });
-  return selected as TApi;
-};
-
-export const createCoreApi = (call: CoreApi['call']): InjectedApi<CoreApi> => {
-  const api = createAllCoreApi(call);
-  const extensionMethodNames = new Set<string>([
-    ...TEST_API_METHOD_NAMES,
-    ...FACTORY_API_METHOD_NAMES,
-  ]);
-  return Object.fromEntries(
-    Object.entries(api).filter(([methodName]) => !extensionMethodNames.has(methodName))
-  ) as InjectedApi<CoreApi>;
-};
-
-export const createTestApi = (call: CoreApi['call']): TestApiMethods =>
-  pickApiMethods<TestApiMethods>(createAllCoreApi(call), TEST_API_METHOD_NAMES);
-
-export const createFactoryApi = (call: CoreApi['call']): FactoryApi =>
-  pickApiMethods<FactoryApi>(createAllCoreApi(call), FACTORY_API_METHOD_NAMES);

package/src/protocols/protocol-v2/resources.ts

@@ -4,6 +4,7 @@ import { PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE } from '@onekeyfe/hd-transport';
 import type {
   IProtocolV2BootResources,
   IProtocolV2Resource,
+  IProtocolV2ResourceFile,
   IProtocolV2ResourceType,
   IProtocolV2Resources,
 } from '../../types';
@@ -247,23 +248,53 @@ function validateBootResources(value: unknown): IProtocolV2BootResources {
   if (resource.required !== false) {
     throw new Error('Invalid Pro2 boot resources required flag: expected false');
   }
-  if (resource.target !== 'CRATE') {
-    throw new Error('Invalid Pro2 boot resources target: expected CRATE');
+  if (resource.target !== 'RES') {
+    throw new Error('Invalid Pro2 boot resources target: expected RES');
   }
-  if (typeof resource.url !== 'string' || !resource.url.startsWith('https://')) {
-    throw new Error('Invalid Pro2 boot resources url');
+  if (
+    resource.manifestUrl !== undefined &&
+    (typeof resource.manifestUrl !== 'string' || !resource.manifestUrl.startsWith('https://'))
+  ) {
+    throw new Error('Invalid Pro2 boot resources manifestUrl');
   }
-  if (!Number.isSafeInteger(resource.size) || Number(resource.size) <= 0) {
-    throw new Error('Invalid Pro2 boot resources size');
+  if (!Array.isArray(resource.files) || resource.files.length === 0) {
+    throw new Error('Invalid Pro2 boot resources files');
+  }
+  const files = resource.files.map((value, index): IProtocolV2ResourceFile => {
+    if (!value || typeof value !== 'object') {
+      throw new Error(`Invalid Pro2 boot resource file at files[${index}]`);
+    }
+    const file = value as Partial<IProtocolV2ResourceFile>;
+    if (typeof file.url !== 'string' || !file.url.startsWith('https://')) {
+      throw new Error(`Invalid Pro2 boot resource url at files[${index}]`);
+    }
+    if (
+      typeof file.devicePath !== 'string' ||
+      !file.devicePath.startsWith('vol0:/') ||
+      file.devicePath.includes('..') ||
+      file.devicePath.includes('\\\\')
+    ) {
+      throw new Error(`Invalid Pro2 boot resource devicePath at files[${index}]`);
+    }
+    if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
+      throw new Error(`Invalid Pro2 boot resource size at files[${index}]`);
+    }
+    return {
+      ...(typeof file.name === 'string' && file.name ? { name: file.name } : undefined),
+      url: file.url,
+      devicePath: file.devicePath,
+      size: Number(file.size),
+      fileHash: normalizeHex(file.fileHash, SHA256_HEX_LENGTH, `boot files[${index}].fileHash`),
+    };
+  });
+  if (new Set(files.map(file => file.devicePath)).size !== files.length) {
+    throw new Error('Invalid Pro2 boot resources files: duplicate devicePath');
   }
   return {
     required: false,
-    target: 'CRATE',
-    url: resource.url,
-    size: Number(resource.size),
-    fileHash: normalizeHex(resource.fileHash, SHA256_HEX_LENGTH, 'boot fileHash'),
-    payloadHash: normalizeHex(resource.payloadHash, SHA3_512_HEX_LENGTH, 'boot payloadHash'),
-    headerHash: normalizeHex(resource.headerHash, SHA3_512_HEX_LENGTH, 'boot headerHash'),
+    target: 'RES',
+    ...(resource.manifestUrl ? { manifestUrl: resource.manifestUrl } : undefined),
+    files,
   };
 }
 
@@ -352,7 +383,7 @@ function bytesToHex(bytes: Uint8Array): string {
 /** Verify the complete downloaded file before any device mutation. */
 export function isProtocolV2ResourceFileValid(
   binary: ArrayBuffer,
-  resource: Pick<IProtocolV2Resource, 'size' | 'fileHash'>
+  resource: Pick<IProtocolV2ResourceFile, 'size' | 'fileHash'>
 ): boolean {
   if (binary.byteLength !== resource.size) return false;
   return bytesToHex(sha256(new Uint8Array(binary))) === resource.fileHash.toLowerCase();

package/src/types/api/checkAllFirmwareRelease.ts

@@ -54,7 +54,7 @@ export type AllFirmwareRelease = {
   bridge?: FirmwareRelease;
   features?: Features;
   protocol?: 'V1' | 'V2';
-  deviceType?: 'pro2';
+  deviceType?: 'pro2' | 'neo';
   firmwareType?: EFirmwareType;
   status?: ProtocolV2FirmwareReleaseStatus;
   hasUpgrade?: boolean;

package/src/types/api/firmwareUpdate.ts

@@ -83,8 +83,6 @@ export interface FirmwareUpdateV4Params {
   romloaderBinary?: ArrayBuffer;
   /** FW_MGMT_TARGET_BOOTLOADER = 3 */
   bootloaderBinary?: ArrayBuffer;
-  /** FW_MGMT_TARGET_CRATE = 1; optional Pro2 startup resources. */
-  bootResourcesBinary?: ArrayBuffer;
   /** FW_MGMT_TARGET_APPLICATION_P1 = 4 */
   applicationP1Binary?: ArrayBuffer;
   /** FW_MGMT_TARGET_APPLICATION_P2 = 5 */
@@ -98,12 +96,14 @@ export interface FirmwareUpdateV4Params {
   se04Binary?: ArrayBuffer;
   forcedUpdateRes?: boolean;
   /**
-   * RESC bundle okpkg files written directly to devicePath through FilesystemFileWrite.
-   * Manual mode installs them without version comparison.
+   * Arbitrary Protocol V2 resource files written directly with FilesystemFileWrite.
+   * Use this for manifest-driven boot resources and other non-RESC files.
    */
-  resourceBundleFiles?: Array<{
+  resourceFiles?: Array<{
     binary: ArrayBuffer;
     devicePath: string;
+    size?: number;
+    fileHash?: string;
   }>;
 }