@onekeyfe/hd-core 1.2.0-alpha.66 → 1.2.0-alpha.67

package/src/api/GetPassphraseState.ts

@@ -1,5 +1,4 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { refreshProtocolV2DeviceStatus } from '../protocols/protocol-v2/walletSession';
@@ -25,12 +24,7 @@ export default class GetPassphraseState extends BaseMethod {
     if (isProtocolV2 && this.payload.useEmptyPassphrase !== true) {
       const features = await refreshProtocolV2DeviceStatus(this.device);
       if (features.unlocked === false) {
-        await this.device.unlockDevice(DeviceSessionPinType.Main, {
-          source: 'unlock-coordinator',
-          reason: 'device-locked',
-          deviceOnly: true,
-          method: 'getPassphraseState',
-        });
+        await this.device.unlockDevice();
       }
     }
     const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(

package/src/api/OpenWalletSession.ts

@@ -1,5 +1,4 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
 import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
@@ -84,7 +83,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
   init() {
     this.useDevicePassphraseState = false;
-    this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
     this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
@@ -92,40 +90,23 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    const state = await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
-    const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
-      candidate.status.unlocked === true &&
-      typeof candidate.status.passphraseProtection === 'boolean' &&
-      typeof candidate.status.unlockedAttachPin === 'boolean';
-    const requireAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) => {
-      if (!hasAuthoritativeProtocolV2WalletStatus(candidate)) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
-      }
-      return candidate;
-    };
     const requireDeviceId = () => {
       if (!currentDeviceId) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
       }
       return currentDeviceId;
     };
-    const refreshProtocolV2DeviceState = async () => {
-      state = await this.device.getDeviceState({ refreshSections: ['status'] });
-      currentDeviceId = state.identity.deviceId;
-      return state;
+    const refreshProtocolV2DeviceId = async () => {
+      const refreshedState = await this.device.getDeviceState({ refreshSections: ['status'] });
+      currentDeviceId = refreshedState.identity.deviceId;
+      return requireDeviceId();
     };
-    const ensureProtocolV2WalletStatus = async () => {
-      if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
-        await this.device.unlockDevice(DeviceSessionPinType.Main, {
-          source: 'unlock-coordinator',
-          reason: 'device-locked',
-          deviceOnly: true,
-          method: 'openWalletSession',
-        });
-        requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
+    const unlockProtocolV2IfLocked = async () => {
+      if (isProtocolV2 && state.status.unlocked === false) {
+        await this.device.unlockDevice();
       }
-      return state;
     };
 
     const protocol = isProtocolV2 ? 'V2' : 'V1';
@@ -133,25 +114,13 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     if (this.params.mode === OpenWalletSessionMode.Standard) {
       this.device.passphraseState = undefined;
       const session = isProtocolV2
-        ? await getProtocolV2WalletSession(this.device, {
-            onlyMainPin: true,
-            deriveCardano: this.payload.deriveCardano,
-            selectMainWalletBeforeRestore:
-              !hasAuthoritativeProtocolV2WalletStatus(state) ||
-              state.status.unlockedAttachPin === true,
-          })
+        ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
-      const refreshedState = isProtocolV2
-        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
-        : state;
-      const deviceId = requireDeviceId();
-      if (
-        session.unlockedAttachPin ||
-        (isProtocolV2 && refreshedState.status.unlockedAttachPin === true)
-      ) {
+      const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
+      if (session.unlockedAttachPin) {
         try {
           await this.device.lockDevice();
         } catch {
@@ -171,8 +140,8 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
     if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
       if (isProtocolV2) {
-        await ensureProtocolV2WalletStatus();
-        const refreshedDeviceId = requireDeviceId();
+        await unlockProtocolV2IfLocked();
+        const refreshedDeviceId = await refreshProtocolV2DeviceId();
         if (refreshedDeviceId !== this.params.deviceId) {
           deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
           throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
@@ -197,7 +166,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             expectedPassphraseState: this.params.passphraseState,
-            deriveCardano: this.payload.deriveCardano,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             expectPassphraseState: this.params.passphraseState,
@@ -217,37 +185,15 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     }
 
     this.device.passphraseState = undefined;
-    const walletStatus = await ensureProtocolV2WalletStatus();
-    if (isProtocolV2 && walletStatus.status.passphraseProtection !== true) {
-      this.device.clearInternalState();
-      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
-    }
-    const readCurrentAttachPinSession =
-      isProtocolV2 && walletStatus.status.unlockedAttachPin === true;
+    await unlockProtocolV2IfLocked();
     const session = isProtocolV2
-      ? await getProtocolV2WalletSession(this.device, {
-          ...(readCurrentAttachPinSession
-            ? { readCurrentAttachPinSession: true }
-            : { forceWalletSelection: true }),
-          deriveCardano: this.payload.deriveCardano,
-        })
+      ? await getProtocolV2WalletSession(this.device, { forceWalletSelection: true })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
-    const refreshedState = isProtocolV2
-      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
-      : state;
-    const deviceId = requireDeviceId();
-    if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {
+    const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
+    if (isProtocolV2 && this.device.getCurrentPassphraseProtection() !== true) {
       this.device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
     }
-    if (
-      isProtocolV2 &&
-      readCurrentAttachPinSession &&
-      refreshedState.status.unlockedAttachPin !== true
-    ) {
-      this.device.clearInternalState();
-      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
-    }
     const responseBase = {
       protocol,
       deviceId,

package/src/api/SearchDevices.ts

@@ -59,9 +59,7 @@ export default class SearchDevices extends BaseMethod {
         // Discovery is best effort. Browsers may retain WebUSB grants for devices that
         // are offline, busy, or not ready, so one descriptor must not abort the scan.
         const result = await DevicePool.getDevices([descriptor], descriptor.path, {
-          // Discovery must actively identify the protocol instead of trusting a caller hint.
-          connectProtocol: undefined,
-          forceProtocolDetection: true,
+          connectProtocol: this.payload.connectProtocol,
           refreshRuntimeState: true,
         });
         deviceList.push(...result.deviceList);

package/src/api/allnetwork/AllNetworkGetAddress.ts

@@ -24,28 +24,24 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
     const resultMap: Record<string, AllNetworkAddress> = {};
     const { bundle } = this.payload as AllNetworkGetAddressParams;
 
-    const methodParams = bundle.map((param, index) =>
-      this.generateMethodName({
-        network: param.network,
-        payload: param,
-        originalIndex: index,
-      })
-    );
-    const groupedMethodParams = methodParams.reduce((groups, param) => {
-      const group = groups.get(param.methodName) ?? [];
-      group.push(param);
-      groups.set(param.methodName, group);
-      return groups;
-    }, new Map<keyof CoreApi, MethodParams[]>());
-    const requiresProtocolV2WalletHandoff =
-      this.device.isProtocolV2() &&
-      (this.payload.useEmptyPassphrase === true || !!this.payload.passphraseState);
-    const methodGroups: [keyof CoreApi, MethodParams[]][] = requiresProtocolV2WalletHandoff
-      ? methodParams.map(param => [param.methodName, [param]])
-      : Array.from(groupedMethodParams.entries());
+    const methodGroups = bundle
+      .map((param, index) =>
+        this.generateMethodName({
+          network: param.network,
+          payload: param,
+          originalIndex: index,
+        })
+      )
+      .reduce((acc, cur) => {
+        if (!acc[cur.methodName]) {
+          acc[cur.methodName] = [];
+        }
+        acc[cur.methodName].push(cur);
+        return acc;
+      }, {} as Record<keyof CoreApi, MethodParams[]>);
 
     let i = 0;
-    for (const [methodName, params] of methodGroups) {
+    for (const [methodName, params] of Object.entries(methodGroups)) {
       const methodParams = {
         bundle: params.map(param => ({
           ...param.params,
@@ -56,7 +52,11 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
         throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
       }
       // call method
-      const response = await this.callMethod(methodName, methodParams, rootFingerprint);
+      const response = await this.callMethod(
+        methodName as keyof CoreApi,
+        methodParams,
+        rootFingerprint
+      );
 
       if (this.abortController?.signal.aborted) {
         throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -14,7 +14,6 @@ import { findMethod } from '../utils';
 import { DEVICE, IFRAME, createUiMessage } from '../../events';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
-import { runMethodWithUnlockPolicy } from '../../protocols/protocol-v2/unlockPolicyRunner';
 import {
   completeRequestContext,
   createRequestContext,
@@ -376,38 +375,16 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
 
       preCheckDeviceSupport(this.device, method);
-      const response = await runMethodWithUnlockPolicy<any[]>(method, this.device, {
-        context: this.protocolV2UnlockContext,
-        prepare: async () => {
-          if (this.temporarySafetyCheckPrompted) {
-            method.temporarySafetyCheckPrompted = true;
-          } else {
-            const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
-            if (appliedTemporarySafetyCheck) {
-              this.temporarySafetyCheckPrompted = true;
-            }
-          }
-
-          // Protocol V2 hands a wallet session to exactly one blockchain request.
-          // The parent all-network call consumes its first handoff while fetching
-          // the root fingerprint, so each nested chain method must resume the
-          // requested standard or hidden wallet before sending its device command.
-          const useEmptyPassphrase = this.payload.useEmptyPassphrase === true;
-          const deriveCardano = method.name.startsWith('cardano');
-          const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
-          if (this.device.isProtocolV2() && shouldResumeWalletSession) {
-            const passphraseStateSafety = await this.device.checkPassphraseStateSafety(
-              this.payload.passphraseState,
-              useEmptyPassphrase,
-              this.payload.skipPassphraseCheck,
-              deriveCardano
-            );
-            if (!passphraseStateSafety) {
-              throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
-            }
-          }
-        },
-      });
+      if (this.temporarySafetyCheckPrompted) {
+        method.temporarySafetyCheckPrompted = true;
+      } else {
+        const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
+        if (appliedTemporarySafetyCheck) {
+          this.temporarySafetyCheckPrompted = true;
+        }
+      }
+
+      const response = await method.run();
 
       if (!Array.isArray(response) || response.length === 0) {
         throw new Error('No response');
@@ -462,9 +439,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       show_display: false,
     });
 
-    if (!this.device.isProtocolV2()) {
-      this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
-    }
+    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
 
     if (res.message.root_fingerprint == null) {
       throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);

package/src/api/device/DeviceSettings.ts

@@ -7,6 +7,7 @@ import { validateParams } from '../helpers/paramsValidator';
 import {
   mapApplySettingsToState,
   mapCommonSettingsToProtocolV2,
+  mapDeviceSettingsToState,
 } from '../../device/DeviceStateMapper';
 import { getProtocolV2SettingsBehavior } from '../../protocols/protocol-v2/settingsUnlockPolicy';
 import {
@@ -162,8 +163,6 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
   async run() {
     try {
       if (this.device.isProtocolV2()) {
-        const refreshStatusAndSettings = () =>
-          this.device.getDeviceState({ refreshSections: ['status', 'settings'] });
         assertSettingsSupported(this.payload, DEVICE_SETTINGS_V1_ONLY_FIELDS, 'Protocol V2');
         const capabilities = getDeviceSettingsCapabilities(
           this.device.getCurrentDeviceType(),
@@ -195,7 +194,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DevicePassphrase,
           });
-          const updated = await refreshStatusAndSettings();
+          const updated = await this.device.getDeviceState({ refreshSections: ['status'] });
           const lockedAfterDisabling =
             requestedPassphrase === false &&
             current.status.unlocked === true &&
@@ -220,7 +219,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DeviceAirgap,
           });
-          const updated = await refreshStatusAndSettings();
+          const updated = await this.device.getDeviceState({ refreshSections: ['settings'] });
           if (updated.settings.airgapMode !== requestedAirgap) {
             throw TypedError(
               HardwareErrorCode.RuntimeError,
@@ -236,7 +235,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
         const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
           settings,
         });
-        await refreshStatusAndSettings();
+        this.device.updateState(mapDeviceSettingsToState(settings), 'settings-write');
         return res.message;
       }
 

package/src/api/device/DeviceUnlock.ts

@@ -1,18 +1,13 @@
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
-
 import { BaseMethod } from '../BaseMethod';
 
-import type { DeviceUnlockParams } from '../../types/api/deviceUnlock';
+import type { LockDevice } from '@onekeyfe/hd-transport';
 
-export default class DeviceUnlock extends BaseMethod<DeviceUnlockParams> {
+export default class DeviceUnlock extends BaseMethod<LockDevice> {
   getSupportedProtocols() {
     return ['V1', 'V2'] as const;
   }
 
   init() {
-    this.params = {
-      pinType: this.payload.pinType ?? DeviceSessionPinType.Main,
-    };
     this.useDevicePassphraseState = false;
     this.unlockPolicy = 'none';
     this.protocolV2UiInteraction = {
@@ -26,6 +21,6 @@ export default class DeviceUnlock extends BaseMethod<DeviceUnlockParams> {
   }
 
   async run() {
-    return this.device.unlockDevice(this.params.pinType, { emitUiEvent: false });
+    return this.device.unlockDevice();
   }
 }

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,15 +5,24 @@ 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 } from '../firmware/uploadFirmware';
+import { updateBootloader, updateBootloaderFromSource } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength } from '../firmware/updateBootloader';
+import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
+import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
+import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
+import {
+  assertFirmwareUpdatePreparedPlanBinding,
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
+} from '../firmware/FirmwareUpdatePreparedPlan';
+import { getDeviceType, getDeviceUUID } from '../../utils';
+import { resolveDeviceBootloaderMode } from '../../utils/deviceFeaturesCompat';
 
 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() {
@@ -43,17 +52,68 @@ 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;
   }) {
-    let { binary } = this.payload;
+    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;
     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)
@@ -68,7 +128,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!checkBootloaderLength(binary)) {
+    if (!binary || !checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -76,7 +136,8 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     if (features && device.isBootloader()) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      return this.updateBootloaderWithEmmcFileWrite(device, binary);
+      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
+      return result;
     }
 
     if (features && !device.isBootloader()) {
@@ -96,13 +157,71 @@ 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,
+        bootloaderMode: resolveDeviceBootloaderMode(features),
+        deviceModel: String(getDeviceType(features)),
+      });
+      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().catch(() => undefined);
+      }
+    }
 
+    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 });
+      return this.updateTouchBootloader({
+        device,
+        features,
+        firmwareType,
+        binary,
+      });
     }
 
     return Promise.resolve(true);