@onekeyfe/hd-core 1.2.0-alpha.31 → 1.2.0-alpha.32

package/src/api/OpenWalletSession.ts

@@ -5,6 +5,7 @@ import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSessi
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';
 import { invalidParameter } from './helpers/paramsValidator';
+import { OpenWalletSessionMode } from '../types/api/openWalletSession';
 
 import type {
   OpenWalletSessionParams,
@@ -44,9 +45,9 @@ const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionPar
     throw invalidParameter('Parameter [mode] is required.');
   }
   if (
-    payload.mode !== 'standard' &&
-    payload.mode !== 'select-hidden' &&
-    payload.mode !== 'resume-hidden'
+    payload.mode !== OpenWalletSessionMode.Standard &&
+    payload.mode !== OpenWalletSessionMode.SelectHidden &&
+    payload.mode !== OpenWalletSessionMode.ResumeHidden
   ) {
     throw invalidParameter(
       'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
@@ -57,7 +58,10 @@ const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionPar
       'Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.'
     );
   }
-  if (payload.mode === 'standard' || payload.mode === 'select-hidden') {
+  if (
+    payload.mode === OpenWalletSessionMode.Standard ||
+    payload.mode === OpenWalletSessionMode.SelectHidden
+  ) {
     if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
       throw invalidParameter(
         'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
@@ -66,7 +70,7 @@ const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionPar
     return { mode: payload.mode };
   }
   return {
-    mode: 'resume-hidden',
+    mode: OpenWalletSessionMode.ResumeHidden,
     deviceId: requiredString(payload.deviceId, 'deviceId'),
     passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
   };
@@ -81,7 +85,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
     this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
-    this.payload.useEmptyPassphrase = this.params.mode === 'standard';
+    this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
   }
 
   async run(): Promise<OpenWalletSessionPayload> {
@@ -102,7 +106,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
     const protocol = isProtocolV2 ? 'V2' : 'V1';
 
-    if (this.params.mode === 'standard') {
+    if (this.params.mode === OpenWalletSessionMode.Standard) {
       this.device.passphraseState = undefined;
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
@@ -129,7 +133,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       };
     }
 
-    if (this.params.mode === 'resume-hidden') {
+    if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
       if (isProtocolV2) {
         if (this.device.features?.unlocked === false) {
           await this.device.unlockDevice();

package/src/api/PromptWebDeviceAccess.ts

@@ -52,13 +52,9 @@ export default class PromptWebDeviceAccess extends BaseMethod {
 
         if (isWebUsbEnv) {
           const usbDevice = device as USBDevice;
-          let path = usbDevice.serialNumber ?? '';
+          const path = usbDevice.serialNumber;
           if (!path) {
-            // Early Pro2 boards have no USB serial number. Re-enumeration assigns a
-            // session-stable mock path, which is recovered by USBDevice identity here.
-            const diff = await this.connector?.enumerate();
-            const matched = diff?.descriptors?.find(d => (d as any).device === usbDevice);
-            path = matched?.path ?? '';
+            throw ERRORS.TypedError(HardwareErrorCode.WebDevicePromptAccessError);
           }
           devicesDescriptor = [
             {

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,23 +5,15 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { FirmwareUpdateTipMessage } from '../../events/ui-request';
 import { FirmwareUpdateBaseMethod } from '../firmware/FirmwareUpdateBaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
-import { updateBootloader, updateBootloaderFromSource } from '../firmware/uploadFirmware';
+import { updateBootloader } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
-import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
-import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
-import {
-  assertFirmwareUpdatePreparedPlanBinding,
-  assertFirmwareUpdatePreparedPlanDeviceIdentity,
-} from '../firmware/FirmwareUpdatePreparedPlan';
-import { getDeviceUUID } from '../../utils';
+import { checkBootloaderLength } from '../firmware/updateBootloader';
 
 import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Device } from '../../device/Device';
 import type { Features } from '../../types';
-import type { FirmwareByteSource } from '../firmware/FirmwareArtifactSource';
 
 export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any> {
   init() {
@@ -51,68 +43,17 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     return true;
   }
 
-  async updateBootloaderWithEmmcFileWriteFromSource(_device: Device, source: FirmwareByteSource) {
-    const filePath = '0:boot/bootloader.bin';
-
-    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
-    await this.emmcCommonUpdateProcessFromSource({
-      source,
-      filePath,
-    });
-    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
-    await this.reboot(RebootType.Normal);
-    this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloaderSuccess);
-    return true;
-  }
-
   async updateTouchBootloader({
     device,
     features,
     firmwareType,
-    binary: preparedBinary,
-    source: preparedSource,
   }: {
     device: Device;
     features?: Features;
     firmwareType: EFirmwareType;
-    binary?: ArrayBuffer;
-    source?: FirmwareByteSource;
   }) {
-    if (preparedSource) {
-      if (!(await checkBootloaderSourceLength(preparedSource))) {
-        throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
-      }
-      if (features && device.isBootloader()) {
-        this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-        const result = await this.updateBootloaderWithEmmcFileWriteFromSource(
-          device,
-          preparedSource
-        );
-        return result;
-      }
-      if (features && !device.isBootloader()) {
-        await updateBootloaderFromSource(
-          this.device.getCommands().typedCall.bind(this.device.getCommands()),
-          this.postMessage,
-          device,
-          preparedSource
-        );
-        return true;
-      }
-    }
-
-    let binary = preparedBinary;
+    let { binary } = this.payload;
     if (!binary) {
-      if (DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Bootloader must be prepared by the external firmware host',
-          {
-            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-            artifactName: 'bootloader',
-          }
-        );
-      }
       this.postTipMessage(FirmwareUpdateTipMessage.CheckLatestUiResource);
       const resourceUrl = features
         ? DataManager.getBootloaderResource(features, firmwareType)
@@ -127,7 +68,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!binary || !checkBootloaderLength(binary)) {
+    if (!checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -135,8 +76,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     if (features && device.isBootloader()) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
-      return result;
+      return this.updateBootloaderWithEmmcFileWrite(device, binary);
     }
 
     if (features && !device.isBootloader()) {
@@ -156,69 +96,13 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const { features } = device;
 
     const payload = this.payload as DeviceUpdateBootloaderParams;
-    const hostBinding = payload.artifact
-      ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-      : undefined;
-    const executionParams = {
-      ...payload,
-      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
-    };
-    if (payload.artifact) {
-      assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan: payload.preparedPlan,
-        deviceIdentity: getDeviceUUID(features) || undefined,
-      });
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: payload.preparedPlan,
-        executor: 'v2',
-        scopeTargets: ['bootloader'],
-        bindings: [
-          {
-            target: 'bootloader',
-            artifact: payload.artifact,
-          },
-        ],
-      });
-      const source = await openFirmwareByteSource({
-        artifact: payload.artifact,
-        reader: executionParams.artifactReader,
-      });
-      if (!source) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Bootloader artifact is not prepared'
-        );
-      }
-      try {
-        const deviceType = device.getCurrentDeviceType();
-        const deviceFirmwareType = device.getCurrentFirmwareType();
-        const firmwareType = payload.firmwareType ?? deviceFirmwareType;
-        if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-          return await this.updateTouchBootloader({
-            device,
-            features,
-            firmwareType,
-            source,
-          });
-        }
-        return true;
-      } finally {
-        await source.close();
-      }
-    }
 
-    const { binary } = payload;
     const deviceType = device.getCurrentDeviceType();
     const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-      return this.updateTouchBootloader({
-        device,
-        features,
-        firmwareType,
-        binary,
-      });
+      return this.updateTouchBootloader({ device, features, firmwareType });
     }
 
     return Promise.resolve(true);

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -14,7 +14,6 @@ import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
 import { createFirmwareProgressThrottle } from './progressThrottle';
-import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
 import type {
   IFirmwareUpdateProgressType,
@@ -25,7 +24,6 @@ import type { RebootType } from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
@@ -389,54 +387,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
   }
 
-  async emmcCommonUpdateProcessFromSource({
-    source,
-    filePath,
-    processedSize,
-    totalSize,
-  }: {
-    source: FirmwareByteSource;
-    filePath: string;
-    processedSize?: number;
-    totalSize?: number;
-  }) {
-    if (!filePath.startsWith('0:')) {
-      throw new Error('filePath must start with 0:');
-    }
-    const env = DataManager.getSettings('env');
-    const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
-
-    await writeFirmwareByteSource({
-      source,
-      chunkSize,
-      write: async ({ data, sourceOffset, length, first }) => {
-        const progress =
-          totalSize !== undefined && processedSize !== undefined
-            ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
-            : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
-        const writeRes = await this.emmcFileWriteWithRetry(
-          filePath,
-          length,
-          sourceOffset,
-          data,
-          first,
-          progress
-        );
-        if (!writeRes) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.EmmcFileWriteFirmwareError,
-            'transfer data error'
-          );
-        }
-        const processedBytes = Number(writeRes.message.processed_byte);
-        this.postProgressMessage(progress, 'transferData');
-        return Number.isFinite(processedBytes) ? processedBytes : length;
-      },
-    });
-
-    return totalSize !== undefined ? (processedSize ?? 0) + source.size : 0;
-  }
-
   async emmcFileWriteWithRetry(
     filePath: string,
     chunkLength: number,

package/src/api/firmware/updateBootloader.ts

@@ -8,7 +8,6 @@ import { shouldUpdateBootloaderForClassicAndMini } from './bootloaderHelper';
 
 import type { Features } from '../../types';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 export function checkNeedUpdateBootForTouch(features: Features, firmwareType: EFirmwareType) {
   const deviceType = getDeviceType(features);
@@ -63,7 +62,8 @@ export function checkNeedUpdateBootForClassicAndMini({
 }
 
 const INIT_DATA_CHUNK_SIZE = 16 * 1024;
-const readBootloaderLength = (chunk: Uint8Array) => {
+export function checkBootloaderLength(data: ArrayBuffer) {
+  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
   const buffer = ByteBuffer.wrap(chunk, undefined, undefined, true);
   buffer.LE();
   // byte 'O', 'K', 'T', 'B'
@@ -77,21 +77,6 @@ const readBootloaderLength = (chunk: Uint8Array) => {
   buffer.readUint32();
   // codelen
   const codelen = buffer.readUint32();
-  return hdrlen + codelen;
-};
-
-export function checkBootloaderLength(data: ArrayBuffer) {
-  if (data.byteLength < 16) {
-    return false;
-  }
-  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
-  return readBootloaderLength(chunk) === data.byteLength;
+  const bootloaderLength = hdrlen + codelen;
+  return bootloaderLength === data.byteLength;
 }
-
-export const checkBootloaderSourceLength = async (source: FirmwareByteSource) => {
-  if (source.size < 16) {
-    return false;
-  }
-  const chunk = new Uint8Array(await source.readAt(0, Math.min(INIT_DATA_CHUNK_SIZE, source.size)));
-  return readBootloaderLength(chunk) === source.size;
-};

package/src/api/firmware/uploadFirmware.ts

@@ -10,7 +10,6 @@ import { bytesToHex } from '../helpers/hexUtils';
 import { DataManager } from '../../data-manager';
 import { DevicePool } from '../../device/DevicePool';
 import { buildProtocolV1FeaturesPayload } from '../../deviceProfile';
-import { openFirmwareByteSource, readFirmwareByteSourceFully } from './FirmwareArtifactSource';
 
 import type { KnownDevice } from '../../types';
 import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
@@ -18,7 +17,6 @@ import type { PROTO } from '../../constants';
 import type { CoreMessage, IFirmwareUpdateProgressType } from '../../events';
 import type { Success } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
 const SESSION_ERROR = 'session not found';
@@ -90,20 +88,17 @@ export const waitBleInstall = async (updateType: string) => {
   }
 };
 
-const toArrayBuffer = (payload: ArrayBuffer | Buffer): ArrayBuffer => {
-  if (payload instanceof ArrayBuffer) {
-    return payload;
-  }
-  return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength).slice().buffer;
-};
-
-export const uploadFirmwareFromSource = async (
+export const uploadFirmware = async (
   updateType: 'firmware' | 'ble',
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: FirmwareByteSource,
-  rebootOnSuccess?: boolean,
+  {
+    payload,
+    rebootOnSuccess,
+  }: PROTO.FirmwareUpload & {
+    rebootOnSuccess?: boolean;
+  },
   isUpdateBootloader?: boolean
 ) => {
   const deviceType = device.getCurrentDeviceType();
@@ -124,20 +119,20 @@ export const uploadFirmwareFromSource = async (
       if (supportUpgradeFileHeader) {
         // Extract and validate firmware header (first 1KB)
         const HEADER_SIZE = 1024;
-        if (source.size < HEADER_SIZE) {
+        if (payload.byteLength < HEADER_SIZE) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `firmware payload too small: ${source.size} bytes, expected at least ${HEADER_SIZE} bytes`
+            `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`
           );
         }
 
         Log.debug('Uploading firmware header:', {
           size: HEADER_SIZE,
-          totalSize: source.size,
+          totalSize: payload.byteLength,
         });
         postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
 
-        const header = new Uint8Array(await source.readAt(0, HEADER_SIZE));
+        const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
 
         try {
           const headerRes = await typedCall('UpgradeFileHeader', 'Success', {
@@ -174,9 +169,6 @@ export const uploadFirmwareFromSource = async (
     postProgressMessage(device, 0, 'installingFirmware', postMessage);
     let updateResponse: TypedResponseMessage<'Success'>;
     try {
-      // Classic/Mini bootloaders accept one protobuf payload and do not expose
-      // a request-range protocol. Other device families remain fully streamed.
-      const payload = await readFirmwareByteSourceFully(source);
       updateResponse = await typedCall('FirmwareUpload', 'Success', {
         payload,
       });
@@ -208,7 +200,9 @@ export const uploadFirmwareFromSource = async (
           updateType,
           postMessage,
           device,
-          source,
+          {
+            payload,
+          },
           rebootOnSuccess
         );
         return response.message;
@@ -217,7 +211,7 @@ export const uploadFirmwareFromSource = async (
 
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const length = source.size;
+    const length = payload.byteLength;
 
     let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
     postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
@@ -226,7 +220,7 @@ export const uploadFirmwareFromSource = async (
       const start = response.message.offset!;
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const end = response.message.offset! + response.message.length!;
-      const chunk = await source.readAt(start, end - start);
+      const chunk = payload.slice(start, end);
 
       if (start > 0) {
         postProgressMessage(
@@ -255,45 +249,11 @@ export const uploadFirmwareFromSource = async (
   throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown device model');
 };
 
-export const uploadFirmware = async (
-  updateType: 'firmware' | 'ble',
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  {
-    payload,
-    rebootOnSuccess,
-  }: PROTO.FirmwareUpload & {
-    rebootOnSuccess?: boolean;
-  },
-  isUpdateBootloader?: boolean
-) => {
-  const source = await openFirmwareByteSource({
-    binary: toArrayBuffer(payload),
-  });
-  if (!source) {
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware payload is empty');
-  }
-  try {
-    return await uploadFirmwareFromSource(
-      updateType,
-      typedCall,
-      postMessage,
-      device,
-      source,
-      rebootOnSuccess,
-      isUpdateBootloader
-    );
-  } finally {
-    await source.close();
-  }
-};
-
 const newTouchUpdateProcess = async (
   updateType: 'firmware' | 'ble',
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: FirmwareByteSource,
+  { payload }: PROTO.FirmwareUpload,
   rebootOnSuccess = true
 ) => {
   let typedCall = device.getCommands().typedCall.bind(device.getCommands());
@@ -303,13 +263,13 @@ const newTouchUpdateProcess = async (
   const env = DataManager.getSettings('env');
   const perPackageSize = DataManager.isBleConnect(env) ? 16 : 128;
   const chunkSize = 1024 * perPackageSize;
-  const totalChunks = Math.ceil(source.size / chunkSize);
+  const totalChunks = Math.ceil(payload.byteLength / chunkSize);
   let offset = 0;
   for (let i = 0; i < totalChunks; i++) {
     const chunkStart = i * chunkSize;
-    const chunkEnd = Math.min(chunkStart + chunkSize, source.size);
+    const chunkEnd = Math.min(chunkStart + chunkSize, payload.byteLength);
     const chunkLength = chunkEnd - chunkStart;
-    const chunk = await source.readAt(chunkStart, chunkLength);
+    const chunk = payload.slice(chunkStart, chunkEnd);
     const overwrite = i === 0;
     const progress = Math.round(((i + 1) / totalChunks) * 100);
     const writeRes = await emmcFileWriteWithRetry(
@@ -530,67 +490,6 @@ export const updateResource = async (
   return processResourceRequest(typedCall, res, data);
 };
 
-export const updateResourceFromSource = async (
-  typedCall: TypedCall,
-  fileName: string,
-  source: FirmwareByteSource,
-  onConfirmAfter?: () => void
-) => {
-  const initialLength = Math.min(INIT_DATA_CHUNK_SIZE, source.size);
-  const initialChunk = new Uint8Array(await source.readAt(0, initialLength));
-  let response = await typedCall('ResourceUpdate', ['ResourceRequest', 'Success'], {
-    file_name: fileName,
-    data_length: source.size,
-    initial_data_chunk: bytesToHex(initialChunk),
-    hash: bytesToHex(blake2s(initialChunk)),
-  });
-  onConfirmAfter?.();
-
-  while (response.type !== 'Success') {
-    const { offset, data_length: dataLength } = response.message;
-    if (
-      !Number.isSafeInteger(offset) ||
-      offset === undefined ||
-      offset < 0 ||
-      !Number.isSafeInteger(dataLength) ||
-      dataLength === undefined ||
-      dataLength <= 0 ||
-      offset + dataLength > source.size
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Device requested an invalid firmware resource range'
-      );
-    }
-    const chunk = new Uint8Array(await source.readAt(offset, dataLength));
-    response = await typedCall('ResourceAck', ['ResourceRequest', 'Success'], {
-      data_chunk: bytesToHex(chunk),
-      hash: bytesToHex(blake2s(chunk)),
-    });
-  }
-  return response.message;
-};
-
-export const updateResourcesFromSources = async (
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  entries: ReadonlyArray<{ entryName: string; source: FirmwareByteSource }>
-) => {
-  postProgressTip(device, 'UpdateSysResource', postMessage);
-  for (const [index, entry] of entries.entries()) {
-    await updateResourceFromSource(typedCall, entry.entryName, entry.source);
-    postProgressMessage(
-      device,
-      Math.floor(((index + 1) / entries.length) * 100),
-      'installingFirmware',
-      postMessage
-    );
-  }
-  postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
-  return true;
-};
-
 export const updateResources = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
@@ -625,28 +524,11 @@ export const updateBootloader = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  data: ArrayBuffer
-) => {
-  const source = await openFirmwareByteSource({ binary: data });
-  if (!source) {
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'bootloader payload is empty');
-  }
-  try {
-    return await updateBootloaderFromSource(typedCall, postMessage, device, source);
-  } finally {
-    await source.close();
-  }
-};
-
-export const updateBootloaderFromSource = async (
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  source: FirmwareByteSource
+  source: ArrayBuffer
 ) => {
   postProgressTip(device, 'UpdateBootloader', postMessage);
   postProgressMessage(device, Math.floor(0), 'installingFirmware', postMessage);
-  await updateResourceFromSource(typedCall, 'bootloader.bin', source, () => {
+  await updateResource(typedCall, 'bootloader.bin', source, () => {
     postProcessingMessage('resource', postMessage);
   });
   postProgressMessage(device, Math.floor(100), 'installingFirmware', postMessage);

package/src/data/messages/messages-protocol-v2.json

@@ -12513,6 +12513,10 @@
         "passphrase": {
           "type": "string",
           "id": 1
+        },
+        "on_device": {
+          "type": "bool",
+          "id": 2
         }
       }
     },