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

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

@@ -0,0 +1,131 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+
+import { LoggerNames, getLogger } from '../../utils';
+import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
+import { refreshProtocolV2DeviceStatus } from './walletSession';
+
+import type { BaseMethod } from '../../api/BaseMethod';
+import type { Device } from '../../device/Device';
+import type { HardwareUiInteractionMeta } from '../../events';
+import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
+
+const Log = getLogger(LoggerNames.Core);
+
+export type ProtocolV2UnlockContext = {
+  preflightCompleted: boolean;
+};
+
+export const createProtocolV2UnlockContext = (): ProtocolV2UnlockContext => ({
+  preflightCompleted: false,
+});
+
+type RunnableMethod = Pick<
+  BaseMethod,
+  | 'run'
+  | 'unlockPolicy'
+  | 'useDevicePassphraseState'
+  | 'protocolV2UiInteraction'
+  | 'protocolV2UiMode'
+  | 'params'
+  | 'payload'
+> & {
+  name?: string;
+  protocolV2UnlockContext?: ProtocolV2UnlockContext;
+};
+
+type UiInteractionCoordinator = Pick<
+  ProtocolV2UiInteractionCoordinator,
+  'enterMethodInteraction' | 'enterUnlockInteraction'
+>;
+
+type RunMethodWithUnlockPolicyOptions<T> = {
+  context?: ProtocolV2UnlockContext;
+  uiCoordinator?: UiInteractionCoordinator;
+  afterStatusBeforeUnlock?: () => void | Promise<void>;
+  prepare?: () => Promise<void>;
+  run?: () => Promise<T>;
+};
+
+const resolvePreUnlockPinType = (method: RunnableMethod) => {
+  const targetsKnownHiddenWallet =
+    method.useDevicePassphraseState &&
+    method.payload?.useEmptyPassphrase !== true &&
+    typeof method.payload?.passphraseState === 'string' &&
+    method.payload.passphraseState.length > 0;
+
+  // A hidden-wallet call may be unlocked by either its Attach PIN or the main
+  // PIN followed by passphrase selection. Wallet-session verification still
+  // rejects a different hidden wallet after the device is unlocked.
+  return targetsKnownHiddenWallet ? DeviceSessionPinType.Any : DeviceSessionPinType.Main;
+};
+
+export async function runMethodWithUnlockPolicy<T = unknown>(
+  method: RunnableMethod,
+  device: Device,
+  options: RunMethodWithUnlockPolicyOptions<T> = {}
+): Promise<T> {
+  const {
+    context = createProtocolV2UnlockContext(),
+    uiCoordinator,
+    afterStatusBeforeUnlock,
+    prepare,
+    run: configuredRun,
+  } = options;
+  const run = configuredRun ?? (() => method.run() as Promise<T>);
+  method.protocolV2UnlockContext = context;
+
+  const shouldEmitUi = isProtocolV2UiEnabled(method);
+  const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
+  const requiresPreUnlock =
+    device.isProtocolV2() &&
+    (method.useDevicePassphraseState || method.unlockPolicy === 'unlock-before-run') &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.();
+
+  if (requiresPreUnlock && !context.preflightCompleted) {
+    const status = await refreshProtocolV2DeviceStatus(device);
+    if (typeof status?.unlocked !== 'boolean') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 DeviceStatus did not report an explicit unlock state.'
+      );
+    }
+
+    await afterStatusBeforeUnlock?.();
+
+    if (!status.unlocked) {
+      const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
+        ? uiCoordinator.enterUnlockInteraction(method.name)
+        : undefined;
+      const unlockedStatus = await device.unlockDevice(
+        resolvePreUnlockPinType(method),
+        shouldCoordinateUi
+          ? { emitUiEvent: false, interaction: unlockInteraction }
+          : {
+              source: 'unlock-coordinator',
+              reason: 'device-locked',
+              deviceOnly: true,
+              method: method.name,
+            }
+      );
+      if (unlockedStatus?.unlocked !== true) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Protocol V2 device remained locked after the unlock flow.'
+        );
+      }
+      Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
+    }
+
+    context.preflightCompleted = true;
+  }
+
+  await prepare?.();
+
+  if (shouldCoordinateUi) {
+    uiCoordinator.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
+  }
+
+  return run();
+}

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

@@ -1,5 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
 
 import { DEVICE } from '../../events';
 import { assertCompleteDeviceSession } from './deviceSession';
@@ -38,32 +38,74 @@ export async function refreshProtocolV2DeviceStatus(device: Device) {
   return device.updateProtocolV2Status(status);
 }
 
-const negotiateEventlessWalletSession = async (device: Device) => {
-  await device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
-    eventless_wallet_session: true,
+export async function ensureProtocolV2WalletSessionUnlocked(device: Device) {
+  if (!device.isProtocolV2() || device.isBootloader?.() || device.isRomloader?.()) {
+    return false;
+  }
+
+  await refreshProtocolV2DeviceStatus(device);
+  if (device.state?.status.unlocked !== false) {
+    return false;
+  }
+
+  await device.unlockDevice(DeviceSessionPinType.Main, {
+    source: 'unlock-coordinator',
+    reason: 'device-locked',
+    deviceOnly: true,
   });
+  return true;
+}
+
+const negotiateEventlessWalletSession = async (device: Device) => {
+  await device.ensureProtocolV2RuntimeContext();
 };
 
 const getDeviceSession = async (device: Device, request: DeviceSessionGet) =>
   device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
 
+const buildDeviceSessionGetRequest = ({
+  sessionId,
+  expectedPassphraseState,
+  deriveCardano,
+}: {
+  sessionId?: string;
+  expectedPassphraseState?: string;
+  deriveCardano?: boolean;
+} = {}): DeviceSessionGet => ({
+  ...(sessionId ? { session_id: sessionId } : {}),
+  ...(expectedPassphraseState ? { btc_test_address: expectedPassphraseState } : {}),
+  seed_domains:
+    deriveCardano === undefined
+      ? []
+      : [
+          DeviceSessionSeedDomain.SeedDomain_Standard,
+          ...(deriveCardano ? [DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
+        ],
+});
+
 const askDevicePassphrase = async (device: Device, requestPayload: DeviceSessionAskPassphrase) => {
   await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', requestPayload);
   await refreshProtocolV2DeviceStatus(device);
 };
 
-const selectDeviceSession = async (device: Device, expectedPassphraseState?: string) => {
+const selectDeviceSession = async (
+  device: Device,
+  expectedPassphraseState?: string,
+  deriveCardano?: boolean
+) => {
   const existsAttachPinUser = device.features?.attachToPinEnabled === true;
   const metadata = {
     source: 'wallet-session-coordinator' as const,
     reason: expectedPassphraseState ? ('session-recovery' as const) : ('open-wallet' as const),
     ...(expectedPassphraseState ? { expectedPassphraseState } : {}),
   };
+  const passphraseInteraction = device.createProtocolV2UiPhaseMetadata?.('passphrase', 'start');
   const response = await device.commands.promptPassphrase(
     {
       existsAttachPinUser,
       deviceOnly: false,
       ...metadata,
+      ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
     },
     { cancelDeviceOnReject: false }
   );
@@ -102,9 +144,16 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
         'Attach PIN wallet selection is unavailable on this device.'
       );
     }
-    device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, metadata);
-    await device.unlockDevice(DeviceSessionPinType.AttachToPin);
-    return getDeviceSession(device, {});
+    const attachPinInteraction = device.createProtocolV2UiPhaseMetadata?.('pin', 'start');
+    device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, {
+      ...metadata,
+      ...(attachPinInteraction ? { interaction: attachPinInteraction } : {}),
+    });
+    await device.unlockDevice(DeviceSessionPinType.AttachToPin, {
+      emitUiEvent: false,
+      interaction: attachPinInteraction,
+    });
+    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
   }
 
   if (hasHostPassphrase) {
@@ -112,12 +161,19 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
       passphrase: hostPassphrase,
       on_device: false,
     });
-    return getDeviceSession(device, {});
+    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
   }
 
-  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
+  const passphraseOnDeviceInteraction = device.createProtocolV2UiPhaseMetadata?.(
+    'passphrase-on-device',
+    'start'
+  );
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, {
+    ...metadata,
+    ...(passphraseOnDeviceInteraction ? { interaction: passphraseOnDeviceInteraction } : {}),
+  });
   await askDevicePassphrase(device, { on_device: true });
-  return getDeviceSession(device, {});
+  return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
 };
 
 export async function getProtocolV2WalletSession(
@@ -128,11 +184,18 @@ export async function getProtocolV2WalletSession(
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
+    /** 业务安全校验遇到 Attach PIN 上下文时直接拒绝，不主动切换钱包。 */
+    rejectAttachPinForMainWallet?: boolean;
+    selectMainWalletBeforeRestore?: boolean;
     resumeOnly?: boolean;
+    deriveCardano?: boolean;
+    /** Read the wallet already selected by Attach PIN without reopening wallet selection. */
+    readCurrentAttachPinSession?: boolean;
   }
 ) {
   const forceWalletSelection =
     options?.forceWalletSelection === true || options?.initSession === true;
+  const readCurrentAttachPinSession = options?.readCurrentAttachPinSession === true;
 
   if (forceWalletSelection) {
     if (options.onlyMainPin) {
@@ -145,33 +208,114 @@ export async function getProtocolV2WalletSession(
 
   await negotiateEventlessWalletSession(device);
 
-  if (options?.onlyMainPin) {
+  if (options?.onlyMainPin || readCurrentAttachPinSession) {
     device.passphraseState = undefined;
   }
-  let expectedPassphraseState = options?.onlyMainPin
-    ? undefined
-    : options?.expectedPassphraseState ?? device.passphraseState;
+  let expectedPassphraseState =
+    options?.onlyMainPin || readCurrentAttachPinSession
+      ? undefined
+      : options?.expectedPassphraseState ?? device.passphraseState;
 
   const cachedStandardSession = options?.onlyMainPin
     ? device.getStandardInternalState?.()
     : undefined;
   const cachedSessionId =
-    !options?.onlyMainPin && typeof device.getInternalState === 'function'
+    !options?.onlyMainPin &&
+    !readCurrentAttachPinSession &&
+    typeof device.getInternalState === 'function'
       ? device.getInternalState()
       : undefined;
   let response;
   let resumed = false;
+  let mainPinSelected =
+    options?.onlyMainPin === true &&
+    device.features?.unlocked === true &&
+    device.features?.unlockedAttachPin === false;
 
-  if (options?.onlyMainPin) {
+  const clearCurrentWalletSession = () => {
+    if (options?.onlyMainPin) {
+      device.clearStandardInternalState?.();
+    } else {
+      device.clearInternalState();
+    }
+  };
+
+  const rejectMismatchedAttachPinWallet = async () => {
+    const features = await refreshProtocolV2DeviceStatus(device);
+    if (features.unlockedAttachPin !== true) {
+      return;
+    }
+
+    try {
+      await device.lockDevice();
+    } catch {
+      // Reject the mismatched Attach PIN wallet even when older firmware cannot lock.
+    }
+    if (options?.rejectAttachPinForMainWallet) {
+      device.clearStandardInternalState?.();
+      device.clearInternalState();
+    } else {
+      clearCurrentWalletSession();
+    }
+    throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+  };
+
+  if (options?.onlyMainPin && options.rejectAttachPinForMainWallet) {
+    await rejectMismatchedAttachPinWallet();
+  }
+
+  const selectMainPin = async (force = false) => {
+    if (force || !mainPinSelected) {
+      await device.unlockDevice(DeviceSessionPinType.Main, {
+        source: 'wallet-session-coordinator',
+        reason: expectedPassphraseState ? 'session-recovery' : 'open-wallet',
+        deviceOnly: true,
+      });
+      mainPinSelected = true;
+    }
+  };
+
+  const selectStandardWallet = async () => {
+    // Main PIN authenticates the device; an empty host passphrase selects the standard derivation.
+    await selectMainPin();
+    if (device.features?.passphraseProtection === true) {
+      await askDevicePassphrase(device, {
+        passphrase: '',
+        on_device: false,
+      });
+    }
+  };
+
+  if (readCurrentAttachPinSession) {
+    const status = await requestProtocolV2DeviceStatus(device);
+    device.updateProtocolV2Status(status);
+    if (
+      status.unlocked !== true ||
+      status.passphrase_enabled !== true ||
+      status.unlocked_by_attach_to_pin !== true
+    ) {
+      device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+    }
+    response = await getDeviceSession(
+      device,
+      buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
+    );
+  } else if (options?.onlyMainPin) {
     expectedPassphraseState = cachedStandardSession?.passphraseState;
     if (cachedStandardSession) {
       try {
-        if (device.features?.unlockedAttachPin === true) {
-          await device.unlockDevice(DeviceSessionPinType.Main);
+        if (options?.selectMainWalletBeforeRestore) {
+          await selectMainPin();
         }
-        response = await getDeviceSession(device, {
-          session_id: cachedStandardSession.sessionId,
-        });
+        response = await getDeviceSession(
+          device,
+          buildDeviceSessionGetRequest({
+            sessionId: cachedStandardSession.sessionId,
+            expectedPassphraseState,
+            deriveCardano: options?.deriveCardano,
+          })
+        );
         resumed = true;
       } catch (error) {
         device.clearStandardInternalState?.();
@@ -183,12 +327,22 @@ export async function getProtocolV2WalletSession(
     }
 
     if (!response) {
-      await device.unlockDevice(DeviceSessionPinType.Main);
-      response = await getDeviceSession(device, {});
+      await selectStandardWallet();
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
+      );
     }
   } else if (cachedSessionId && expectedPassphraseState) {
     try {
-      response = await getDeviceSession(device, { session_id: cachedSessionId });
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({
+          sessionId: cachedSessionId,
+          expectedPassphraseState,
+          deriveCardano: options?.deriveCardano,
+        })
+      );
       resumed = true;
     } catch (error) {
       device.clearInternalState();
@@ -197,6 +351,20 @@ export async function getProtocolV2WalletSession(
       }
       resumed = false;
     }
+  } else if (expectedPassphraseState) {
+    try {
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({
+          expectedPassphraseState,
+          deriveCardano: options?.deriveCardano,
+        })
+      );
+    } catch (error) {
+      if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
+        throw error;
+      }
+    }
   }
 
   if (!response) {
@@ -204,7 +372,7 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
-    response = await selectDeviceSession(device, expectedPassphraseState);
+    response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
   }
 
   let { message } = response;
@@ -220,17 +388,21 @@ export async function getProtocolV2WalletSession(
   }
   if (expectedPassphraseState && expectedPassphraseState !== message.btc_test_address) {
     resumed = false;
+    await rejectMismatchedAttachPinWallet();
     if (options?.resumeOnly) {
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
     if (options?.onlyMainPin) {
       device.clearStandardInternalState?.();
-      await device.unlockDevice(DeviceSessionPinType.Main);
-      response = await getDeviceSession(device, {});
+      await selectStandardWallet();
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
+      );
     } else {
       device.clearInternalState();
-      response = await selectDeviceSession(device, expectedPassphraseState);
+      response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
     }
     message = response.message;
     try {
@@ -244,11 +416,8 @@ export async function getProtocolV2WalletSession(
       throw error;
     }
     if (expectedPassphraseState !== message.btc_test_address) {
-      if (options?.onlyMainPin) {
-        device.clearStandardInternalState?.();
-      } else {
-        device.clearInternalState();
-      }
+      await rejectMismatchedAttachPinWallet();
+      clearCurrentWalletSession();
       throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
     }
   }
@@ -266,20 +435,29 @@ export async function getProtocolV2WalletSession(
     device.updateInternalState(...internalStateArgs);
   }
 
+  let unlockedAttachPin: boolean | undefined;
+  if (readCurrentAttachPinSession) {
+    unlockedAttachPin = true;
+  } else if (mainPinSelected) {
+    unlockedAttachPin = false;
+  }
+
   return {
     passphraseState: message.btc_test_address,
     newSession: message.session_id,
-    unlockedAttachPin: device.features?.unlockedAttachPin ?? undefined,
+    unlockedAttachPin,
     resumed,
   };
 }
 
 export async function restoreProtocolV2WalletSession(
   device: Device,
-  expectedPassphraseState: string
+  expectedPassphraseState: string,
+  deriveCardano?: boolean
 ) {
   return getProtocolV2WalletSession(device, {
     expectedPassphraseState,
     resumeOnly: true,
+    deriveCardano,
   });
 }

package/src/topLevelInject.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 
-import { createCoreApi } from './inject';
+import { createCoreApi, createProtocolAwareCall } from './inject';
 import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { ConnectSettings } from './types/settings';
@@ -20,6 +20,7 @@ export const topLevelInject = () => {
     if (!lowLevelApi) return Promise.resolve(undefined);
     return lowLevelApi.call(params);
   };
+  const protocolAwareCall = createProtocolAwareCall(call);
   const api: CoreApi = {
     on: <T extends string, P extends (...args: any[]) => any>(type: T, fn: P) => {
       eventEmitter.on(type, fn);
@@ -38,9 +39,11 @@ export const topLevelInject = () => {
       return lowLevelApi?.init(settings) ?? Promise.resolve(false);
     },
 
-    call,
+    call: protocolAwareCall.call,
 
-    ...createCoreApi(call),
+    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
+
+    ...createCoreApi(protocolAwareCall.call),
 
     removeAllListeners: type => {
       eventEmitter.removeAllListeners(type);

package/src/types/api/checkAllFirmwareRelease.ts

@@ -55,11 +55,12 @@ export type AllFirmwareRelease = {
   bridge?: FirmwareRelease;
   features?: Features;
   protocol?: 'V1' | 'V2';
-  deviceType?: 'pro2';
+  deviceType?: 'pro2' | 'neo';
   firmwareType?: EFirmwareType;
   status?: ProtocolV2FirmwareReleaseStatus;
   hasUpgrade?: boolean;
   required?: boolean;
+  resourceStatus?: 'valid' | 'outdated' | 'unknown';
   currentVersions?: DeviceStateVersions;
   components?: ProtocolV2FirmwareComponentRelease[];
   targetsToUpdate?: FirmwareUpdateV4Target[];
@@ -69,6 +70,7 @@ export type AllFirmwareRelease = {
 
 export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
+  checkFirmwareHash?: boolean;
   firmwareType?: EFirmwareType;
   platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
   forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];

package/src/types/api/detectDeviceConnectProtocol.ts

@@ -0,0 +1,6 @@
+import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
+import type { Response } from '../params';
+
+export declare function detectDeviceConnectProtocol(
+  connectId: string
+): Response<HardwareConnectProtocol>;

package/src/types/api/deviceUnlock.ts

@@ -1,4 +1,15 @@
+import type { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 import type { Features } from '../device';
 import type { CommonParams, Response } from '../params';
 
-export declare function deviceUnlock(connectId: string, params?: CommonParams): Response<Features>;
+export type DeviceUnlockParams = {
+  /**
+   * 限定本次解锁允许使用的 PIN 类型。省略时保持兼容行为，仅允许主 PIN。
+   */
+  pinType?: DeviceSessionPinType;
+};
+
+export declare function deviceUnlock(
+  connectId: string,
+  params?: CommonParams & DeviceUnlockParams
+): Response<Features>;

package/src/types/api/export.ts

@@ -14,6 +14,7 @@ export type {
 export type { CipheredKeyValue, CipheredKeyValueParams } from './cipherKeyValue';
 
 export type { DeviceChangePinParams } from './deviceChangePin';
+export type { DeviceUnlockParams } from './deviceUnlock';
 export type { DeviceFlagsParams } from './deviceFlags';
 export type { DeviceRecoveryParams } from './deviceRecovery';
 export type { DeviceResetParams } from './deviceReset';

package/src/types/api/firmwareUpdate.ts

@@ -118,6 +118,7 @@ export interface FirmwareUpdateV3Params {
  */
 export type FirmwareUpdateV4Target =
   | 'boot'
+  | 'boot_resources'
   | 'app_v1'
   | 'app_v2'
   | 'coprocessor'
@@ -154,12 +155,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;
   }>;
   artifactReader?: FirmwareArtifactReader;
   componentArtifacts?: Partial<