@onekeyfe/hd-core 1.2.0-alpha.21 → 1.2.0-alpha.23

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

@@ -1,5 +1,7 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
+import { DEVICE } from '../../events';
 import { assertCompleteDeviceSession } from './deviceSession';
 import { isDeviceLockedError } from './lockedError';
 
@@ -16,6 +18,12 @@ 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,
+  });
+};
+
 const getDeviceSession = async (device: Device, request: DeviceSessionGet) => {
   try {
     return await device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
@@ -23,11 +31,76 @@ const getDeviceSession = async (device: Device, request: DeviceSessionGet) => {
     if (!isDeviceLockedError(error)) {
       throw error;
     }
-    await device.unlockDevice();
+    await device.unlockDevice(DeviceSessionPinType.Main);
     return device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
   }
 };
 
+const askDevicePassphrase = async (device: Device) => {
+  const request = () =>
+    device.commands.typedCall(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      {},
+      {
+        timeoutMs: 120_000,
+      }
+    );
+  try {
+    return await request();
+  } catch (error) {
+    if (!isDeviceLockedError(error)) {
+      throw error;
+    }
+    await device.unlockDevice(DeviceSessionPinType.Main);
+    return request();
+  }
+};
+
+const selectDeviceSession = async (device: Device) => {
+  const existsAttachPinUser = device.features?.attachToPinEnabled === true;
+  const metadata = {
+    source: 'wallet-session-coordinator' as const,
+    reason: 'open-wallet' as const,
+  };
+  const response = await device.commands.promptPassphrase(
+    { existsAttachPinUser, deviceOnly: true, ...metadata },
+    { cancelDeviceOnReject: false }
+  );
+  const hasHostPassphrase =
+    typeof response.passphrase === 'string' && response.passphrase.length > 0;
+  const selections = [
+    hasHostPassphrase,
+    response.passphraseOnDevice === true,
+    response.attachPinOnDevice === true,
+  ].filter(Boolean).length;
+
+  if (selections !== 1) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Wallet selection must contain exactly one passphrase access mode.'
+    );
+  }
+
+  if (response.attachPinOnDevice) {
+    if (!existsAttachPinUser) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        '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, {});
+  }
+
+  // Protocol V2 no longer accepts host-provided passphrase text. A legacy host
+  // response is treated only as the user's choice to continue on the device.
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
+  await askDevicePassphrase(device);
+  return getDeviceSession(device, {});
+};
+
 export async function getProtocolV2WalletSession(
   device: Device,
   options?: {
@@ -38,18 +111,22 @@ export async function getProtocolV2WalletSession(
 ) {
   if (options?.initSession) {
     device.clearInternalState();
+    device.passphraseState = undefined;
   }
 
-  const expectedPassphraseState = options?.expectedPassphraseState ?? device.passphraseState;
+  await negotiateEventlessWalletSession(device);
+
+  if (options?.onlyMainPin) {
+    device.passphraseState = undefined;
+  }
+  const expectedPassphraseState = options?.onlyMainPin
+    ? undefined
+    : options?.expectedPassphraseState ?? device.passphraseState;
 
-  // Unlock with PIN first. DeviceSessionGet operates on the wallet selected by
-  // the device unlock flow; Protocol V2 does not accept a host passphrase here.
   if (device.features?.unlocked === false) {
-    await device.unlockDevice();
+    await device.unlockDevice(DeviceSessionPinType.Main);
   }
 
-  // A standard wallet needs no DeviceSession. After unlock confirms passphrase is
-  // disabled, do not create or forward a hidden-wallet passphraseState.
   if (options?.onlyMainPin || device.getCurrentPassphraseProtection() === false) {
     return {
       passphraseState: undefined,
@@ -75,7 +152,7 @@ export async function getProtocolV2WalletSession(
   }
 
   if (!response) {
-    response = await getDeviceSession(device, {});
+    response = await selectDeviceSession(device);
   }
 
   const { message } = response;
@@ -95,7 +172,7 @@ export async function getProtocolV2WalletSession(
     message.btc_test_address,
     device.getCurrentDeviceId(),
     message.session_id,
-    options?.initSession ? null : device.features?.sessionId ?? null
+    options?.initSession ? null : cachedSessionId ?? null
   );
 
   return {

package/src/topLevelInject.ts

@@ -1,6 +1,7 @@
 import EventEmitter from 'events';
 
 import { createCoreApi } from './inject';
+import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { ConnectSettings } from './types/settings';
 import type { CoreApi } from './types/api';
@@ -46,7 +47,10 @@ export const topLevelInject = () => {
       lowLevelApi?.removeAllListeners(type);
     },
 
-    dispose: () => lowLevelApi?.dispose(),
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await lowLevelApi?.dispose();
+    },
 
     uiResponse: response => lowLevelApi?.uiResponse(response),
 

package/src/types/api/checkAllFirmwareRelease.ts

@@ -2,6 +2,7 @@ import type { IBLEFirmwareReleaseInfo } from '../settings';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
 import type { Features, IDeviceBLEFirmwareStatus, IDeviceFirmwareStatus } from '../device';
+import type { FirmwareUpdatePlan } from './firmwareUpdatePlan';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -20,11 +21,13 @@ export type AllFirmwareRelease = {
   bootloader?: FirmwareRelease;
   bridge?: FirmwareRelease;
   features?: Features;
+  firmwareUpdatePlan?: FirmwareUpdatePlan;
 };
 
 export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
   firmwareType?: EFirmwareType;
+  platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/deviceUnlock.ts

@@ -1,7 +1,4 @@
-import type { DeviceState } from '../device';
+import type { Features } from '../device';
 import type { CommonParams, Response } from '../params';
 
-export declare function deviceUnlock(
-  connectId: string,
-  params?: CommonParams
-): Response<DeviceState>;
+export declare function deviceUnlock(connectId: string, params?: CommonParams): Response<Features>;

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,11 +25,29 @@ export type {
   DeviceUploadResourceResponse,
 } from './deviceUploadResource';
 export type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+  FirmwareUpdateHostBinding,
+  FirmwareUpdateArtifactParams,
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
   FirmwareUpdateV4Params,
+  FirmwareUpdateV4Target,
 } from './firmwareUpdate';
+export type {
+  FirmwareUpdatePlan,
+  FirmwareUpdatePlanArtifact,
+  FirmwareUpdatePlanArtifactRole,
+  FirmwareUpdatePlanTarget,
+} from './firmwareUpdatePlan';
+export type {
+  FirmwareUpdatePreparedArtifact,
+  FirmwareUpdatePreparedArtifactInput,
+  FirmwareUpdatePreparedEntry,
+  FirmwareUpdatePreparedPlan,
+} from './firmwareUpdatePreparedPlan';
+export type { FirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 
 export type { AllNetworkAddressParams, AllNetworkGetAddressParams } from './allNetworkGetAddress';

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;
+    }>;
+  };
 }
 
 /**
@@ -73,10 +129,14 @@ 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;
@@ -102,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,36 @@
+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 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;

package/src/types/api/getPassphraseState.ts

@@ -3,10 +3,11 @@ import type { CommonParams, Response } from '../params';
 export type GetPassphraseStateParams = CommonParams;
 
 /**
- * Legacy Protocol V1 wallet API.
+ * Compatibility wallet-state API for existing App integrations.
  *
- * This remains supported for Protocol V1 integrations. New cross-protocol integrations
- * and all Protocol V2 callers should use `openWalletSession`.
+ * Protocol V1 keeps its parameterless firmware flow. Protocol V2 maps the existing
+ * `useEmptyPassphrase` and `initSession` intent to the device-only wallet-session flow.
+ * New integrations should prefer `openWalletSession` for explicit wallet intent.
  */
 export declare function getPassphraseState(
   connectId?: string,

package/src/types/api/index.ts

@@ -1,24 +1,7 @@
 import type {
-  deviceFactoryInfoGet,
-  deviceFactoryInfoSet,
-  deviceFirmwareUpdate,
-  deviceGetFirmwareUpdateStatus,
   deviceGetOnboardingStatus,
-  deviceInfoGet,
   deviceReboot,
-  deviceStatusGet,
   deviceUploadWallpaper,
-  dirList,
-  dirMake,
-  dirRemove,
-  fileDelete,
-  fileRead,
-  fileWrite,
-  filesystemFormat,
-  filesystemPermissionFix,
-  pathInfo,
-  ping,
-  protocolInfoRequest,
   uploadPortfolio,
 } from './protocolV2';
 import type { off, on, removeAllListeners } from './event';
@@ -46,7 +29,15 @@ import type {
   firmwareUpdateV2,
   firmwareUpdateV3,
   firmwareUpdateV4,
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
 } from './firmwareUpdate';
+import type { getFirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
+import type {
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
+} from './firmwareUpdatePreparedPlan';
 import type { promptWebDeviceAccess } from './promptWebDeviceAccess';
 import type { deviceReset } from './deviceReset';
 import type { deviceRecovery } from './deviceRecovery';
@@ -236,6 +227,12 @@ export type CoreApi = {
   firmwareUpdateV2: typeof firmwareUpdateV2;
   firmwareUpdateV3: typeof firmwareUpdateV3;
   firmwareUpdateV4: typeof firmwareUpdateV4;
+  registerFirmwareUpdateHostBinding: typeof registerFirmwareUpdateHostBinding;
+  unregisterFirmwareUpdateHostBinding: typeof unregisterFirmwareUpdateHostBinding;
+  getFirmwareUpdateHostBindingGeneration: typeof getFirmwareUpdateHostBindingGeneration;
+  getFirmwareUpdateCapabilities: typeof getFirmwareUpdateCapabilities;
+  prepareFirmwareUpdatePlan: typeof prepareFirmwareUpdatePlan;
+  validateFirmwareUpdatePreparedPlan: typeof validateFirmwareUpdatePreparedPlan;
   cipherKeyValue: typeof cipherKeyValue;
 
   /**
@@ -244,24 +241,7 @@ export type CoreApi = {
   deviceReboot: typeof deviceReboot;
   deviceGetOnboardingStatus: typeof deviceGetOnboardingStatus;
   deviceUploadWallpaper: typeof deviceUploadWallpaper;
-  deviceInfoGet: typeof deviceInfoGet;
-  deviceStatusGet: typeof deviceStatusGet;
-  protocolInfoRequest: typeof protocolInfoRequest;
-  ping: typeof ping;
-  deviceFirmwareUpdate: typeof deviceFirmwareUpdate;
-  deviceGetFirmwareUpdateStatus: typeof deviceGetFirmwareUpdateStatus;
-  deviceFactoryInfoSet: typeof deviceFactoryInfoSet;
-  deviceFactoryInfoGet: typeof deviceFactoryInfoGet;
-  filesystemPermissionFix: typeof filesystemPermissionFix;
-  filesystemFormat: typeof filesystemFormat;
   uploadPortfolio: typeof uploadPortfolio;
-  fileRead: typeof fileRead;
-  fileWrite: typeof fileWrite;
-  fileDelete: typeof fileDelete;
-  dirList: typeof dirList;
-  dirMake: typeof dirMake;
-  dirRemove: typeof dirRemove;
-  pathInfo: typeof pathInfo;
 
   /**
    * All network function

package/src/types/api/openWalletSession.ts

@@ -40,6 +40,8 @@ type OpenWalletSessionPayloadBase = {
   protocol: 'V1' | 'V2';
   deviceId: string;
   resumed: boolean;
+  /** Forwarded only when the firmware response contains a wallet session id. */
+  sessionId?: string;
 };
 
 export type OpenWalletSessionPayload = OpenWalletSessionPayloadBase &