@onekeyfe/hd-core 1.2.0-alpha.50 → 1.2.0-alpha.52

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

@@ -1,5 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { DEVICE } from '../../events';
 import { assertCompleteDeviceSession } from './deviceSession';
@@ -38,74 +38,32 @@ export async function refreshProtocolV2DeviceStatus(device: Device) {
   return device.updateProtocolV2Status(status);
 }
 
-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();
+  await device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+    eventless_wallet_session: true,
+  });
 };
 
 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,
-  deriveCardano?: boolean
-) => {
+const selectDeviceSession = async (device: Device, expectedPassphraseState?: string) => {
   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 }
   );
@@ -144,16 +102,9 @@ const selectDeviceSession = async (
         'Attach PIN wallet selection is unavailable on this 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 }));
+    device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, metadata);
+    await device.unlockDevice(DeviceSessionPinType.AttachToPin);
+    return getDeviceSession(device, {});
   }
 
   if (hasHostPassphrase) {
@@ -161,19 +112,12 @@ const selectDeviceSession = async (
       passphrase: hostPassphrase,
       on_device: false,
     });
-    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+    return getDeviceSession(device, {});
   }
 
-  const passphraseOnDeviceInteraction = device.createProtocolV2UiPhaseMetadata?.(
-    'passphrase-on-device',
-    'start'
-  );
-  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, {
-    ...metadata,
-    ...(passphraseOnDeviceInteraction ? { interaction: passphraseOnDeviceInteraction } : {}),
-  });
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
   await askDevicePassphrase(device, { on_device: true });
-  return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+  return getDeviceSession(device, {});
 };
 
 export async function getProtocolV2WalletSession(
@@ -184,9 +128,7 @@ export async function getProtocolV2WalletSession(
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
-    selectMainWalletBeforeRestore?: boolean;
     resumeOnly?: boolean;
-    deriveCardano?: boolean;
   }
 ) {
   const forceWalletSelection =
@@ -219,71 +161,17 @@ export async function getProtocolV2WalletSession(
       : undefined;
   let response;
   let resumed = false;
-  let mainPinSelected =
-    options?.onlyMainPin === true &&
-    device.features?.unlocked === true &&
-    device.features?.unlockedAttachPin === false;
-
-  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.
-    }
-    clearCurrentWalletSession();
-    throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
-  };
-
-  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 (options?.onlyMainPin) {
     expectedPassphraseState = cachedStandardSession?.passphraseState;
     if (cachedStandardSession) {
       try {
-        if (options?.selectMainWalletBeforeRestore) {
-          await selectMainPin();
+        if (device.features?.unlockedAttachPin === true) {
+          await device.unlockDevice(DeviceSessionPinType.Main);
         }
-        response = await getDeviceSession(
-          device,
-          buildDeviceSessionGetRequest({
-            sessionId: cachedStandardSession.sessionId,
-            expectedPassphraseState,
-            deriveCardano: options?.deriveCardano,
-          })
-        );
+        response = await getDeviceSession(device, {
+          session_id: cachedStandardSession.sessionId,
+        });
         resumed = true;
       } catch (error) {
         device.clearStandardInternalState?.();
@@ -295,22 +183,12 @@ export async function getProtocolV2WalletSession(
     }
 
     if (!response) {
-      await selectStandardWallet();
-      response = await getDeviceSession(
-        device,
-        buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
-      );
+      await device.unlockDevice(DeviceSessionPinType.Main);
+      response = await getDeviceSession(device, {});
     }
   } else if (cachedSessionId && expectedPassphraseState) {
     try {
-      response = await getDeviceSession(
-        device,
-        buildDeviceSessionGetRequest({
-          sessionId: cachedSessionId,
-          expectedPassphraseState,
-          deriveCardano: options?.deriveCardano,
-        })
-      );
+      response = await getDeviceSession(device, { session_id: cachedSessionId });
       resumed = true;
     } catch (error) {
       device.clearInternalState();
@@ -319,20 +197,6 @@ 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) {
@@ -340,7 +204,7 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
-    response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+    response = await selectDeviceSession(device, expectedPassphraseState);
   }
 
   let { message } = response;
@@ -356,21 +220,17 @@ 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 selectStandardWallet();
-      response = await getDeviceSession(
-        device,
-        buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
-      );
+      await device.unlockDevice(DeviceSessionPinType.Main);
+      response = await getDeviceSession(device, {});
     } else {
       device.clearInternalState();
-      response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+      response = await selectDeviceSession(device, expectedPassphraseState);
     }
     message = response.message;
     try {
@@ -384,8 +244,11 @@ export async function getProtocolV2WalletSession(
       throw error;
     }
     if (expectedPassphraseState !== message.btc_test_address) {
-      await rejectMismatchedAttachPinWallet();
-      clearCurrentWalletSession();
+      if (options?.onlyMainPin) {
+        device.clearStandardInternalState?.();
+      } else {
+        device.clearInternalState();
+      }
       throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
     }
   }
@@ -406,19 +269,17 @@ export async function getProtocolV2WalletSession(
   return {
     passphraseState: message.btc_test_address,
     newSession: message.session_id,
-    unlockedAttachPin: mainPinSelected ? false : undefined,
+    unlockedAttachPin: device.features?.unlockedAttachPin ?? undefined,
     resumed,
   };
 }
 
 export async function restoreProtocolV2WalletSession(
   device: Device,
-  expectedPassphraseState: string,
-  deriveCardano?: boolean
+  expectedPassphraseState: string
 ) {
   return getProtocolV2WalletSession(device, {
     expectedPassphraseState,
     resumeOnly: true,
-    deriveCardano,
   });
 }

package/src/topLevelInject.ts

@@ -1,6 +1,7 @@
 import EventEmitter from 'events';
 
-import { createCoreApi, createProtocolAwareCall } from './inject';
+import { createCoreApi } from './inject';
+import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { ConnectSettings } from './types/settings';
 import type { CoreApi } from './types/api';
@@ -19,7 +20,6 @@ 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,18 +38,19 @@ export const topLevelInject = () => {
       return lowLevelApi?.init(settings) ?? Promise.resolve(false);
     },
 
-    call: protocolAwareCall.call,
+    call,
 
-    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
-
-    ...createCoreApi(protocolAwareCall.call),
+    ...createCoreApi(call),
 
     removeAllListeners: type => {
       eventEmitter.removeAllListeners(type);
       lowLevelApi?.removeAllListeners(type);
     },
 
-    dispose: () => lowLevelApi?.dispose(),
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await lowLevelApi?.dispose();
+    },
 
     uiResponse: response => lowLevelApi?.uiResponse(response),
 

package/src/types/api/checkAllFirmwareRelease.ts

@@ -12,6 +12,7 @@ import type {
   IProtocolV2FirmwareComponentTarget,
 } from '../settings';
 import type { FirmwareUpdateV4Target } from './firmwareUpdate';
+import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -59,16 +60,18 @@ export type AllFirmwareRelease = {
   status?: ProtocolV2FirmwareReleaseStatus;
   hasUpgrade?: boolean;
   required?: boolean;
-  resourceStatus?: 'valid' | 'outdated' | 'unknown';
   currentVersions?: DeviceStateVersions;
   components?: ProtocolV2FirmwareComponentRelease[];
   targetsToUpdate?: FirmwareUpdateV4Target[];
   release?: IFirmwareReleaseInfo;
+  firmwareUpdatePlan?: FirmwareUpdatePlan;
 };
 
 export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
   firmwareType?: EFirmwareType;
+  platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
+  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/deviceUpdateBootloader.ts

@@ -1,9 +1,15 @@
 import type { Success } from '@onekeyfe/hd-transport';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { FirmwareArtifactReader, FirmwareArtifactReference } from './firmwareUpdate';
+import type { FirmwareUpdatePreparedPlan } from './firmwareUpdatePreparedPlan';
 import type { Response } from '../params';
 
 export type DeviceUpdateBootloaderParams = {
+  preparedPlan?: FirmwareUpdatePreparedPlan;
+  hostBindingGeneration?: number;
   binary?: ArrayBuffer;
+  artifact?: FirmwareArtifactReference;
+  artifactReader?: FirmwareArtifactReader;
   firmwareType?: EFirmwareType;
 };
 

package/src/types/api/export.ts

@@ -25,12 +25,30 @@ export type {
   DeviceUploadResourceResponse,
 } from './deviceUploadResource';
 export type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+  FirmwareUpdateHostBinding,
+  FirmwareUpdateArtifactParams,
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
   FirmwareUpdateV4Params,
   FirmwareUpdateV4Target,
 } from './firmwareUpdate';
+export type {
+  FirmwareUpdatePlan,
+  FirmwareUpdatePlanArtifact,
+  FirmwareUpdatePlanArtifactRole,
+  FirmwareUpdatePlanForceTarget,
+  FirmwareUpdatePlanTarget,
+} from './firmwareUpdatePlan';
+export type {
+  FirmwareUpdatePreparedArtifact,
+  FirmwareUpdatePreparedArtifactInput,
+  FirmwareUpdatePreparedEntry,
+  FirmwareUpdatePreparedPlan,
+} from './firmwareUpdatePreparedPlan';
+export type { FirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 export type {
   ProtocolV2FirmwareComponentRelease,

package/src/types/api/firmwareUpdate.ts

@@ -1,14 +1,53 @@
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
+import type { FirmwareUpdatePreparedPlan } from './firmwareUpdatePreparedPlan';
 
 type IUpdateType = 'firmware' | 'ble';
 
+export interface FirmwareArtifactReference {
+  artifactRef: string;
+  size: number;
+  sha256: string;
+}
+
+export interface FirmwareArtifactReader {
+  open(input: { artifactRef: string }): Promise<{
+    readerId: string;
+    size: number;
+  }>;
+  read(input: { readerId: string; offset: number; length: number }): Promise<{
+    data: ArrayBuffer;
+    bytesRead: number;
+    eof: boolean;
+  }>;
+  close(input: { readerId: string }): Promise<void>;
+}
+
+export interface FirmwareUpdateHostBinding {
+  artifactReader: FirmwareArtifactReader;
+}
+
 export interface FirmwareUpdateBinaryParams {
   binary: ArrayBuffer;
   updateType: IUpdateType;
 }
 
+export interface FirmwareUpdateArtifactParams {
+  preparedPlan: FirmwareUpdatePreparedPlan;
+  hostBindingGeneration: number;
+  artifact: FirmwareArtifactReference;
+  resourceArtifact?: FirmwareArtifactReference;
+  resourceEntries?: Array<{
+    entryName: string;
+    artifact: FirmwareArtifactReference;
+  }>;
+  updateType: IUpdateType;
+  forcedUpdateRes?: boolean;
+  isUpdateBootloader?: boolean;
+  firmwareType?: EFirmwareType;
+}
+
 export interface FirmwareUpdateParams {
   version?: number[];
   updateType: IUpdateType;
@@ -37,8 +76,14 @@ export declare function firmwareUpdateV2(
   connectId: string | undefined,
   params: Params<FirmwareUpdateBinaryParams & Platform>
 ): Response<PROTO.Success>;
+export declare function firmwareUpdateV2(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdateArtifactParams & Platform>
+): Response<PROTO.Success>;
 
 export interface FirmwareUpdateV3Params {
+  preparedPlan?: FirmwareUpdatePreparedPlan;
+  hostBindingGeneration?: number;
   bleVersion?: number[];
   bleBinary?: ArrayBuffer;
   chunkSize?: number;
@@ -55,6 +100,17 @@ export interface FirmwareUpdateV3Params {
   firmwareType?: EFirmwareType;
 
   platform: IPlatform;
+
+  artifactReader?: FirmwareArtifactReader;
+  artifacts?: {
+    ble?: FirmwareArtifactReference;
+    firmware?: FirmwareArtifactReference;
+    bootloader?: FirmwareArtifactReference;
+    resourceEntries?: Array<{
+      entryName: string;
+      artifact: FirmwareArtifactReference;
+    }>;
+  };
 }
 
 /**
@@ -63,7 +119,6 @@ export interface FirmwareUpdateV3Params {
  */
 export type FirmwareUpdateV4Target =
   | 'boot'
-  | 'boot_resources'
   | 'app_v1'
   | 'app_v2'
   | 'coprocessor'
@@ -74,17 +129,19 @@ export type FirmwareUpdateV4Target =
   | 'se04';
 
 export interface FirmwareUpdateV4Params {
+  preparedPlan?: FirmwareUpdatePreparedPlan;
+  hostBindingGeneration?: number;
   platform: IPlatform;
+  expectedDeviceId?: string;
   chunkSize?: number;
   firmwareType?: EFirmwareType;
   targetsToUpdate?: FirmwareUpdateV4Target[];
+  expectedTargetVersions?: Partial<Record<FirmwareUpdateV4Target, string>>;
 
   /** FW_MGMT_TARGET_ROMLOADER = 2; Pro2 cannot install it through firmwareUpdateV4. */
   romloaderBinary?: ArrayBuffer;
   /** FW_MGMT_TARGET_BOOTLOADER = 3 */
   bootloaderBinary?: ArrayBuffer;
-  /** FW_MGMT_TARGET_CRATE = 1; optional Pro2 startup resources. */
-  bootResourcesBinary?: ArrayBuffer;
   /** FW_MGMT_TARGET_APPLICATION_P1 = 4 */
   applicationP1Binary?: ArrayBuffer;
   /** FW_MGMT_TARGET_APPLICATION_P2 = 5 */
@@ -105,8 +162,24 @@ export interface FirmwareUpdateV4Params {
     binary: ArrayBuffer;
     devicePath: string;
   }>;
+  artifactReader?: FirmwareArtifactReader;
+  componentArtifacts?: Partial<
+    Record<Exclude<FirmwareUpdateV4Target, 'resource'>, FirmwareArtifactReference>
+  >;
+  resourceBundleArtifacts?: Array<{
+    name: string;
+    artifact: FirmwareArtifactReference;
+  }>;
 }
 
+export declare function registerFirmwareUpdateHostBinding(
+  binding: FirmwareUpdateHostBinding
+): number;
+
+export declare function unregisterFirmwareUpdateHostBinding(generation?: number): boolean;
+
+export declare function getFirmwareUpdateHostBindingGeneration(): number;
+
 export declare function firmwareUpdateV3(
   connectId: string | undefined,
   params: Params<FirmwareUpdateV3Params>

package/src/types/api/firmwareUpdateCapabilities.ts

@@ -0,0 +1,9 @@
+export interface FirmwareUpdateCapabilities {
+  planSchemaVersion: 2;
+  preparedPlanSchemaVersion: 2;
+  hostBindingProtocolVersion: 2;
+  manifestModes: Array<'external-only' | 'sdk-managed'>;
+  supportsArtifactReader: true;
+}
+
+export declare function getFirmwareUpdateCapabilities(): FirmwareUpdateCapabilities;

package/src/types/api/firmwareUpdatePlan.ts

@@ -0,0 +1,38 @@
+import type { FirmwareUpdateV4Target } from './firmwareUpdate';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
+
+export type FirmwareUpdatePlanArtifactRole =
+  | 'firmware'
+  | 'ble'
+  | 'bootloader'
+  | 'resource'
+  | 'component'
+  | 'resourceBundle';
+
+export type FirmwareUpdatePlanTarget = 'firmware' | 'ble' | 'bootloader' | FirmwareUpdateV4Target;
+
+export type FirmwareUpdatePlanForceTarget = 'firmware' | 'ble' | 'bootloader' | 'resource';
+
+export interface FirmwareUpdatePlanArtifact {
+  artifactId: string;
+  role: FirmwareUpdatePlanArtifactRole;
+  target: FirmwareUpdatePlanTarget;
+  url: string;
+  container: 'raw' | 'zip';
+  logicalName?: string;
+  expectedSize?: number;
+  expectedSha256?: string;
+  targetVersion?: string;
+}
+
+export interface FirmwareUpdatePlan {
+  schemaVersion: 2;
+  planDigest: string;
+  executor: 'v2' | 'v3' | 'v4';
+  deviceIdentity: string;
+  deviceModel: string;
+  firmwareType: EFirmwareType;
+  platform: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
+  artifacts: FirmwareUpdatePlanArtifact[];
+  targetsToUpdate: FirmwareUpdatePlanTarget[];
+}

package/src/types/api/firmwareUpdatePreparedPlan.ts

@@ -0,0 +1,53 @@
+import type { FirmwareArtifactReference } from './firmwareUpdate';
+import type {
+  FirmwareUpdatePlan,
+  FirmwareUpdatePlanArtifactRole,
+  FirmwareUpdatePlanTarget,
+} from './firmwareUpdatePlan';
+
+export interface FirmwareUpdatePreparedEntry {
+  entryName: string;
+  artifact: FirmwareArtifactReference;
+}
+
+export interface FirmwareUpdatePreparedArtifactInput {
+  artifactId: string;
+  artifact: FirmwareArtifactReference;
+  materializedEntries?: FirmwareUpdatePreparedEntry[];
+}
+
+export interface FirmwareUpdatePreparedArtifact {
+  artifactId: string;
+  role: FirmwareUpdatePlanArtifactRole;
+  target: FirmwareUpdatePlanTarget;
+  container: 'raw' | 'zip';
+  logicalName?: string;
+  targetVersion?: string;
+  artifact: FirmwareArtifactReference;
+  materializedEntries?: FirmwareUpdatePreparedEntry[];
+}
+
+export interface FirmwareUpdatePreparedPlan {
+  schemaVersion: 2;
+  preparedPlanDigest: string;
+  planDigest: string;
+  networkPolicy: 'forbid';
+  executor: FirmwareUpdatePlan['executor'];
+  deviceIdentity: string;
+  deviceModel: string;
+  firmwareType: FirmwareUpdatePlan['firmwareType'];
+  platform: FirmwareUpdatePlan['platform'];
+  leaseRef: string;
+  artifacts: FirmwareUpdatePreparedArtifact[];
+  targetsToUpdate: FirmwareUpdatePlanTarget[];
+}
+
+export declare function prepareFirmwareUpdatePlan(input: {
+  plan: FirmwareUpdatePlan;
+  leaseRef: string;
+  artifacts: FirmwareUpdatePreparedArtifactInput[];
+}): FirmwareUpdatePreparedPlan;
+
+export declare function validateFirmwareUpdatePreparedPlan(
+  value: unknown
+): FirmwareUpdatePreparedPlan;