@onekeyfe/hd-core 1.2.0-alpha.41 → 1.2.0-alpha.42

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

@@ -38,10 +38,26 @@ 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) =>
@@ -59,11 +75,13 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
     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,8 +120,15 @@ 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);
+    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, {});
   }
 
@@ -115,7 +140,10 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
     return getDeviceSession(device, {});
   }
 
-  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, {
+    ...metadata,
+    ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
+  });
   await askDevicePassphrase(device, { on_device: true });
   return getDeviceSession(device, {});
 };
@@ -128,7 +156,9 @@ export async function getProtocolV2WalletSession(
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
+    selectMainWalletBeforeRestore?: boolean;
     resumeOnly?: boolean;
+    deriveCardano?: boolean;
   }
 ) {
   const forceWalletSelection =
@@ -161,13 +191,48 @@ export async function getProtocolV2WalletSession(
       : undefined;
   let response;
   let resumed = false;
+  let mainWalletSelected = 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 selectMainWallet = async (force = false) => {
+    if (force || !mainWalletSelected) {
+      await device.unlockDevice(DeviceSessionPinType.Main, {
+        source: 'wallet-session-coordinator',
+        reason: expectedPassphraseState ? 'session-recovery' : 'open-wallet',
+        deviceOnly: true,
+      });
+      mainWalletSelected = true;
+    }
+  };
 
   if (options?.onlyMainPin) {
     expectedPassphraseState = cachedStandardSession?.passphraseState;
     if (cachedStandardSession) {
       try {
-        if (device.features?.unlockedAttachPin === true) {
-          await device.unlockDevice(DeviceSessionPinType.Main);
+        if (options?.selectMainWalletBeforeRestore) {
+          await selectMainWallet();
         }
         response = await getDeviceSession(device, {
           session_id: cachedStandardSession.sessionId,
@@ -183,12 +248,14 @@ export async function getProtocolV2WalletSession(
     }
 
     if (!response) {
-      await device.unlockDevice(DeviceSessionPinType.Main);
+      await selectMainWallet();
       response = await getDeviceSession(device, {});
     }
   } else if (cachedSessionId && expectedPassphraseState) {
     try {
-      response = await getDeviceSession(device, { session_id: cachedSessionId });
+      response = await getDeviceSession(device, {
+        session_id: cachedSessionId,
+      });
       resumed = true;
     } catch (error) {
       device.clearInternalState();
@@ -197,6 +264,14 @@ export async function getProtocolV2WalletSession(
       }
       resumed = false;
     }
+  } else if (expectedPassphraseState) {
+    try {
+      response = await getDeviceSession(device, {});
+    } catch (error) {
+      if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
+        throw error;
+      }
+    }
   }
 
   if (!response) {
@@ -220,13 +295,14 @@ 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);
+      await selectMainWallet(true);
       response = await getDeviceSession(device, {});
     } else {
       device.clearInternalState();
@@ -244,11 +320,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);
     }
   }
@@ -269,17 +342,19 @@ export async function getProtocolV2WalletSession(
   return {
     passphraseState: message.btc_test_address,
     newSession: message.session_id,
-    unlockedAttachPin: device.features?.unlockedAttachPin ?? undefined,
+    unlockedAttachPin: mainWalletSelected ? false : undefined,
     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,7 +1,6 @@
 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';
@@ -47,10 +46,7 @@ export const topLevelInject = () => {
       lowLevelApi?.removeAllListeners(type);
     },
 
-    dispose: async () => {
-      unregisterFirmwareUpdateHostBinding();
-      await lowLevelApi?.dispose();
-    },
+    dispose: () => lowLevelApi?.dispose(),
 
     uiResponse: response => lowLevelApi?.uiResponse(response),
 

package/src/types/api/checkAllFirmwareRelease.ts

@@ -12,7 +12,6 @@ import type {
   IProtocolV2FirmwareComponentTarget,
 } from '../settings';
 import type { FirmwareUpdateV4Target } from './firmwareUpdate';
-import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -60,18 +59,16 @@ 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,15 +1,9 @@
 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,30 +25,12 @@ 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,53 +1,14 @@
 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;
@@ -76,14 +37,8 @@ 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;
@@ -100,17 +55,6 @@ export interface FirmwareUpdateV3Params {
   firmwareType?: EFirmwareType;
 
   platform: IPlatform;
-
-  artifactReader?: FirmwareArtifactReader;
-  artifacts?: {
-    ble?: FirmwareArtifactReference;
-    firmware?: FirmwareArtifactReference;
-    bootloader?: FirmwareArtifactReference;
-    resourceEntries?: Array<{
-      entryName: string;
-      artifact: FirmwareArtifactReference;
-    }>;
-  };
 }
 
 /**
@@ -129,14 +73,10 @@ 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;
@@ -162,24 +102,8 @@ 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/index.ts

@@ -1,6 +1,7 @@
 import type {
   deviceGetOnboardingStatus,
   deviceReboot,
+  deviceUploadNft,
   deviceUploadWallpaper,
   testProtocolV2Ping,
   uploadPortfolio,
@@ -30,15 +31,7 @@ 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';
@@ -235,12 +228,6 @@ 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;
 
   /**
@@ -248,6 +235,7 @@ export type CoreApi = {
    */
   deviceReboot: typeof deviceReboot;
   deviceGetOnboardingStatus: typeof deviceGetOnboardingStatus;
+  deviceUploadNft: typeof deviceUploadNft;
   deviceUploadWallpaper: typeof deviceUploadWallpaper;
   uploadPortfolio: typeof uploadPortfolio;
 

package/src/types/api/protocolV2.ts

@@ -5,6 +5,10 @@ import type {
   DeviceUploadWallpaperParams,
   DeviceUploadWallpaperResponse,
 } from '../../api/protocol-v2/DeviceUploadWallpaper';
+import type {
+  DeviceUploadNftParams,
+  DeviceUploadNftResponse,
+} from '../../api/protocol-v2/DeviceUploadNft';
 
 // Re-export implementation parameter types as the single source of truth.
 export type { DeviceRebootParams, RebootTypeInput } from '../../api/protocol-v2/helpers';
@@ -12,6 +16,10 @@ export type {
   DeviceUploadWallpaperParams,
   DeviceUploadWallpaperResponse,
 } from '../../api/protocol-v2/DeviceUploadWallpaper';
+export type {
+  DeviceUploadNftParams,
+  DeviceUploadNftResponse,
+} from '../../api/protocol-v2/DeviceUploadNft';
 
 // ── Shared response shapes (Protocol V2 file system) ────────────────────
 
@@ -52,6 +60,11 @@ export declare function deviceUploadWallpaper(
   params: CommonParams & DeviceUploadWallpaperParams
 ): Response<DeviceUploadWallpaperResponse>;
 
+export declare function deviceUploadNft(
+  connectId: string,
+  params: CommonParams & DeviceUploadNftParams
+): Response<DeviceUploadNftResponse>;
+
 export declare function uploadPortfolio(
   connectId: string,
   params: {

package/src/types/settings.ts

@@ -31,8 +31,6 @@ export type ConnectSettings = {
   timestamp: number;
   isFrame?: boolean;
   preRelease?: boolean;
-  firmwareManifestMode?: 'sdk-managed' | 'external-only';
-  preloadedConfig?: RemoteConfigResponse;
   fetchConfig?: boolean;
   extension?: string;
   configFetcher?: (url: string) => Promise<RemoteConfigResponse | null>;
@@ -60,18 +58,39 @@ export type IProtocolV2FirmwareComponent = {
   fingerprint?: string;
   /** OKPP payload hash, used to detect same-version package changes. */
   payloadHash?: string;
-  expectedSize?: number;
   version?: IVersionArray;
 };
 
+export type IProtocolV2ResourceType =
+  | 'images'
+  | 'animation'
+  | 'wallpaper'
+  | 'translations'
+  | 'roobert'
+  | 'noto';
+
+/** Pro2 RES package descriptor. Hashes identify content without a human-managed version. */
+export type IProtocolV2Resource = {
+  type: IProtocolV2ResourceType;
+  url: string;
+  /** Complete okpkg file size in bytes. */
+  size: number;
+  /** SHA-256 of the complete okpkg file. */
+  fileHash: string;
+  /** SHA3-512 header_hash from the signed okpkg header. */
+  headerHash: string;
+};
+
+export type IProtocolV2Resources = {
+  stable: IProtocolV2Resource[];
+};
+
 /** Pro2 RESC bundle okpkg descriptor for incremental FileWrite synchronization. */
 export type IProtocolV2ResourceBundle = {
   /** Bundle name, such as images, animation, translations, or fonts_roobert. */
   name: string;
   /** Download URL. */
   url: string;
-  fingerprint?: string;
-  expectedSize?: number;
   /** Device target path, such as vol0:/bundles/images/images.okpkg. */
   devicePath: string;
   /** okpkg payload_version used to skip matching content after FileRead. */
@@ -93,16 +112,10 @@ export type IFirmwareReleaseInfo = {
   firmwareType?: EFirmwareType;
   /** Firmware UI resource */
   resource?: string;
-  resourceFingerprint?: string;
-  resourceExpectedSize?: number;
   /** Firmware full UI resource */
   fullResource?: string;
-  fullResourceFingerprint?: string;
-  fullResourceExpectedSize?: number;
   fullResourceRange?: string[];
   bootloaderResource?: string;
-  bootloaderFingerprint?: string;
-  bootloaderExpectedSize?: number;
   bootloaderVersion?: IVersionArray;
   displayBootloaderVersion?: IVersionArray;
   bootloaderRelatedFirmwareVersion?: IVersionArray;
@@ -115,7 +128,6 @@ export type IFirmwareReleaseInfo = {
     [k in ILocale]: string;
   };
   fingerprint: string;
-  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
@@ -131,7 +143,6 @@ export type IBLEFirmwareReleaseInfo = {
   webUpdate: string;
   fingerprint: string;
   fingerprintWeb: string;
-  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
@@ -149,6 +160,8 @@ export type DeviceTypeMap = {
     'firmware-v8'?: IFirmwareReleaseInfo[];
     'firmware-btc-v8'?: IFirmwareReleaseInfo[];
     ble: IBLEFirmwareReleaseInfo[];
+    /** Independent Pro2 resource release configuration. */
+    resources?: IProtocolV2Resources;
   };
 };
 

package/src/utils/deviceFeaturesUtils.ts

@@ -106,6 +106,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
     initSession?: boolean;
+    deriveCardano?: boolean;
   }
 ) => {
   if (device.isProtocolV2()) {
@@ -121,6 +122,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
       initSession: options?.initSession,
       expectedPassphraseState: options?.expectPassphraseState,
       onlyMainPin: options?.onlyMainPin,
+      deriveCardano: options?.deriveCardano,
     });
   }
 
@@ -185,6 +187,7 @@ export const getPassphraseState = async (
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
     initSession?: boolean;
+    deriveCardano?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
@@ -205,6 +208,7 @@ export const getPassphraseState = async (
       initSession: options?.initSession,
       expectedPassphraseState: options?.expectPassphraseState,
       onlyMainPin: options?.onlyMainPin,
+      deriveCardano: options?.deriveCardano,
     });
   }