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

package/src/api/GetPassphraseState.ts

@@ -1,4 +1,5 @@
 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';
@@ -24,7 +25,12 @@ 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();
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'getPassphraseState',
+        });
       }
     }
     const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(

package/src/api/OpenWalletSession.ts

@@ -1,4 +1,5 @@
 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';
@@ -83,6 +84,7 @@ 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;
@@ -90,23 +92,40 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    const state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    let 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 refreshProtocolV2DeviceId = async () => {
-      const refreshedState = await this.device.getDeviceState({ refreshSections: ['status'] });
-      currentDeviceId = refreshedState.identity.deviceId;
-      return requireDeviceId();
+    const refreshProtocolV2DeviceState = async () => {
+      state = await this.device.getDeviceState({ refreshSections: ['status'] });
+      currentDeviceId = state.identity.deviceId;
+      return state;
     };
-    const unlockProtocolV2IfLocked = async () => {
-      if (isProtocolV2 && state.status.unlocked === false) {
-        await this.device.unlockDevice();
+    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());
       }
+      return state;
     };
 
     const protocol = isProtocolV2 ? 'V2' : 'V1';
@@ -114,13 +133,25 @@ 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 })
+        ? await getProtocolV2WalletSession(this.device, {
+            onlyMainPin: true,
+            deriveCardano: this.payload.deriveCardano,
+            selectMainWalletBeforeRestore:
+              !hasAuthoritativeProtocolV2WalletStatus(state) ||
+              state.status.unlockedAttachPin === true,
+          })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
-      const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
-      if (session.unlockedAttachPin) {
+      const refreshedState = isProtocolV2
+        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        : state;
+      const deviceId = requireDeviceId();
+      if (
+        session.unlockedAttachPin ||
+        (isProtocolV2 && refreshedState.status.unlockedAttachPin === true)
+      ) {
         try {
           await this.device.lockDevice();
         } catch {
@@ -140,8 +171,8 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
     if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
       if (isProtocolV2) {
-        await unlockProtocolV2IfLocked();
-        const refreshedDeviceId = await refreshProtocolV2DeviceId();
+        await ensureProtocolV2WalletStatus();
+        const refreshedDeviceId = requireDeviceId();
         if (refreshedDeviceId !== this.params.deviceId) {
           deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
           throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
@@ -166,6 +197,7 @@ 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,
@@ -185,15 +217,37 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     }
 
     this.device.passphraseState = undefined;
-    await unlockProtocolV2IfLocked();
+    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;
     const session = isProtocolV2
-      ? await getProtocolV2WalletSession(this.device, { forceWalletSelection: true })
+      ? await getProtocolV2WalletSession(this.device, {
+          ...(readCurrentAttachPinSession
+            ? { readCurrentAttachPinSession: true }
+            : { forceWalletSelection: true }),
+          deriveCardano: this.payload.deriveCardano,
+        })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
-    const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
-    if (isProtocolV2 && this.device.getCurrentPassphraseProtection() !== true) {
+    const refreshedState = isProtocolV2
+      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      : state;
+    const deviceId = requireDeviceId();
+    if (isProtocolV2 && refreshedState.status.passphraseProtection !== 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,7 +59,9 @@ 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, {
-          connectProtocol: this.payload.connectProtocol,
+          // Discovery must actively identify the protocol instead of trusting a caller hint.
+          connectProtocol: undefined,
+          forceProtocolDetection: true,
           refreshRuntimeState: true,
         });
         deviceList.push(...result.deviceList);

package/src/api/allnetwork/AllNetworkGetAddress.ts

@@ -24,24 +24,28 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
     const resultMap: Record<string, AllNetworkAddress> = {};
     const { bundle } = this.payload as AllNetworkGetAddressParams;
 
-    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[]>);
+    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());
 
     let i = 0;
-    for (const [methodName, params] of Object.entries(methodGroups)) {
+    for (const [methodName, params] of methodGroups) {
       const methodParams = {
         bundle: params.map(param => ({
           ...param.params,
@@ -52,11 +56,7 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
         throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
       }
       // call method
-      const response = await this.callMethod(
-        methodName as keyof CoreApi,
-        methodParams,
-        rootFingerprint
-      );
+      const response = await this.callMethod(methodName, methodParams, rootFingerprint);
 
       if (this.abortController?.signal.aborted) {
         throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -14,6 +14,7 @@ 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,
@@ -375,16 +376,38 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
 
       preCheckDeviceSupport(this.device, method);
-      if (this.temporarySafetyCheckPrompted) {
-        method.temporarySafetyCheckPrompted = true;
-      } else {
-        const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
-        if (appliedTemporarySafetyCheck) {
-          this.temporarySafetyCheckPrompted = true;
-        }
-      }
-
-      const response = await method.run();
+      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 (!Array.isArray(response) || response.length === 0) {
         throw new Error('No response');
@@ -439,7 +462,9 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       show_display: false,
     });
 
-    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+    if (!this.device.isProtocolV2()) {
+      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,7 +7,6 @@ import { validateParams } from '../helpers/paramsValidator';
 import {
   mapApplySettingsToState,
   mapCommonSettingsToProtocolV2,
-  mapDeviceSettingsToState,
 } from '../../device/DeviceStateMapper';
 import { getProtocolV2SettingsBehavior } from '../../protocols/protocol-v2/settingsUnlockPolicy';
 import {
@@ -163,6 +162,8 @@ 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(),
@@ -194,7 +195,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DevicePassphrase,
           });
-          const updated = await this.device.getDeviceState({ refreshSections: ['status'] });
+          const updated = await refreshStatusAndSettings();
           const lockedAfterDisabling =
             requestedPassphrase === false &&
             current.status.unlocked === true &&
@@ -219,7 +220,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DeviceAirgap,
           });
-          const updated = await this.device.getDeviceState({ refreshSections: ['settings'] });
+          const updated = await refreshStatusAndSettings();
           if (updated.settings.airgapMode !== requestedAirgap) {
             throw TypedError(
               HardwareErrorCode.RuntimeError,
@@ -235,7 +236,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
         const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
           settings,
         });
-        this.device.updateState(mapDeviceSettingsToState(settings), 'settings-write');
+        await refreshStatusAndSettings();
         return res.message;
       }
 

package/src/api/device/DeviceUnlock.ts

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

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,24 +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 { getDeviceType, getDeviceUUID } from '../../utils';
-import { resolveDeviceBootloaderMode } from '../../utils/deviceFeaturesCompat';
+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() {
@@ -52,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)
@@ -128,7 +68,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!binary || !checkBootloaderLength(binary)) {
+    if (!checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -136,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()) {
@@ -157,71 +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,
-        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();
-      }
-    }
 
-    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);