@onekeyfe/hd-core 1.2.2-alpha.100 → 1.2.2-alpha.102

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

@@ -63,35 +63,50 @@ const negotiateEventlessWalletSession = async (device: Device) => {
 const getDeviceSession = async (device: Device, request: DeviceSessionGet) =>
   device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
 
+const STANDARD_SEED_DOMAINS = [DeviceSessionSeedDomain.SeedDomain_Standard];
+const CARDANO_SEED_DOMAINS = [
+  DeviceSessionSeedDomain.SeedDomain_Standard,
+  DeviceSessionSeedDomain.SeedDomain_Cardano,
+];
+
+const buildDeviceSessionSeedDomains = (deriveCardano?: boolean): DeviceSessionSeedDomain[] =>
+  deriveCardano === true ? CARDANO_SEED_DOMAINS : STANDARD_SEED_DOMAINS;
+
+const deviceSessionHasCardano = (message: { seed_domains?: DeviceSessionSeedDomain[] }) =>
+  Array.isArray(message.seed_domains) &&
+  message.seed_domains.includes(DeviceSessionSeedDomain.SeedDomain_Cardano);
+
+// origin/dev Get is read/resume only. Seed generation lives on AskPassphrase.
 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);
+const askDevicePassphrase = async (
+  device: Device,
+  requestPayload: Omit<DeviceSessionAskPassphrase, 'seed_domains'>,
+  deriveCardano?: boolean,
+  onStatusRefreshed?: () => void
+) => {
+  await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', {
+    ...requestPayload,
+    seed_domains: buildDeviceSessionSeedDomains(deriveCardano),
+  });
   await refreshProtocolV2DeviceStatus(device);
+  onStatusRefreshed?.();
 };
 
 const selectDeviceSession = async (
   device: Device,
   expectedPassphraseState?: string,
-  deriveCardano?: boolean
+  deriveCardano?: boolean,
+  onStatusRefreshed?: () => void
 ) => {
   const existsAttachPinUser = device.features?.attachToPinEnabled === true;
   const metadata = {
@@ -153,15 +168,36 @@ const selectDeviceSession = async (
       emitUiEvent: false,
       interaction: attachPinInteraction,
     });
-    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+    onStatusRefreshed?.();
+    if (deriveCardano === true) {
+      await askDevicePassphrase(
+        device,
+        { passphrase: '', on_device: false },
+        true,
+        onStatusRefreshed
+      );
+      // Firmware AskPassphrase Success clears unlocked_by_attach_to_pin.
+      // Identity is still the Attach PIN wallet; keep the SDK flag so a later
+      // passphrase picker still locks instead of prompting.
+      if (device.features) {
+        device.features.unlockedAttachPin = true;
+      }
+    }
+    const attachPinSession = await getDeviceSession(device, buildDeviceSessionGetRequest());
+    return Object.assign(attachPinSession, { viaAttachPin: true as const });
   }
 
   if (hasHostPassphrase) {
-    await askDevicePassphrase(device, {
-      passphrase: hostPassphrase,
-      on_device: false,
-    });
-    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+    await askDevicePassphrase(
+      device,
+      {
+        passphrase: hostPassphrase,
+        on_device: false,
+      },
+      deriveCardano,
+      onStatusRefreshed
+    );
+    return getDeviceSession(device, buildDeviceSessionGetRequest());
   }
 
   const passphraseOnDeviceInteraction = device.createProtocolV2UiPhaseMetadata?.(
@@ -172,8 +208,8 @@ const selectDeviceSession = async (
     ...metadata,
     ...(passphraseOnDeviceInteraction ? { interaction: passphraseOnDeviceInteraction } : {}),
   });
-  await askDevicePassphrase(device, { on_device: true });
-  return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+  await askDevicePassphrase(device, { on_device: true }, deriveCardano, onStatusRefreshed);
+  return getDeviceSession(device, buildDeviceSessionGetRequest());
 };
 
 export async function getProtocolV2WalletSession(
@@ -191,11 +227,17 @@ export async function getProtocolV2WalletSession(
     deriveCardano?: boolean;
     /** Read the wallet already selected by Attach PIN without reopening wallet selection. */
     readCurrentAttachPinSession?: boolean;
+    /** The current call already selected the Main PIN during its unlock preflight. */
+    mainPinSelected?: boolean;
   }
 ) {
   const forceWalletSelection =
     options?.forceWalletSelection === true || options?.initSession === true;
   const readCurrentAttachPinSession = options?.readCurrentAttachPinSession === true;
+  const sessionIsAttachPinWallet = (session?: unknown) =>
+    readCurrentAttachPinSession ||
+    (session as { viaAttachPin?: boolean } | undefined)?.viaAttachPin === true ||
+    device.features?.unlockedAttachPin === true;
 
   if (forceWalletSelection) {
     if (options.onlyMainPin) {
@@ -227,10 +269,20 @@ export async function getProtocolV2WalletSession(
       : undefined;
   let response;
   let resumed = false;
-  let mainPinSelected =
-    options?.onlyMainPin === true &&
-    device.features?.unlocked === true &&
-    device.features?.unlockedAttachPin === false;
+  let walletStatusRefreshed = false;
+  const markWalletStatusRefreshed = () => {
+    walletStatusRefreshed = true;
+  };
+  if (options?.onlyMainPin && options.mainPinSelected !== true) {
+    await refreshProtocolV2DeviceStatus(device);
+    markWalletStatusRefreshed();
+  }
+  let mainPinAuthenticated =
+    options?.mainPinSelected === true ||
+    (options?.onlyMainPin === true &&
+      device.features?.unlocked === true &&
+      device.features?.unlockedAttachPin === false);
+  let standardWalletSelected = options?.mainPinSelected === true;
 
   const clearCurrentWalletSession = () => {
     if (options?.onlyMainPin) {
@@ -240,8 +292,41 @@ export async function getProtocolV2WalletSession(
     }
   };
 
+  const sessionGetRequest = ({
+    sessionId,
+    expectedPassphraseState: passphraseState,
+  }: {
+    sessionId?: string;
+    expectedPassphraseState?: string;
+  } = {}) =>
+    buildDeviceSessionGetRequest({
+      sessionId,
+      expectedPassphraseState: passphraseState,
+    });
+
+  const askEmptyPassphraseAndGet = async ({
+    deriveCardano,
+    keepAttachPin,
+  }: {
+    deriveCardano?: boolean;
+    keepAttachPin?: boolean;
+  } = {}) => {
+    await askDevicePassphrase(
+      device,
+      { passphrase: '', on_device: false },
+      deriveCardano,
+      markWalletStatusRefreshed
+    );
+    if (keepAttachPin && device.features) {
+      device.features.unlockedAttachPin = true;
+    }
+    const session = await getDeviceSession(device, buildDeviceSessionGetRequest());
+    return keepAttachPin ? Object.assign(session, { viaAttachPin: true as const }) : session;
+  };
+
   const rejectMismatchedAttachPinWallet = async () => {
     const features = await refreshProtocolV2DeviceStatus(device);
+    markWalletStatusRefreshed();
     if (features.unlockedAttachPin !== true) {
       return;
     }
@@ -260,35 +345,63 @@ export async function getProtocolV2WalletSession(
     throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
   };
 
+  // The passphrase picker would prompt. Empty host AskPassphrase does not;
+  // that path is Attach PIN / standard Cardano. Switching to a different
+  // passphrase wallet still locks first.
+  const lockAttachPinBeforePassphraseSelection = async () => {
+    if (readCurrentAttachPinSession || options?.onlyMainPin) {
+      return;
+    }
+    if (device.features?.unlockedAttachPin !== true) {
+      return;
+    }
+    await rejectMismatchedAttachPinWallet();
+  };
+
   if (options?.onlyMainPin && options.rejectAttachPinForMainWallet) {
     await rejectMismatchedAttachPinWallet();
   }
 
   const selectMainPin = async (force = false) => {
-    if (force || !mainPinSelected) {
+    if (force || !mainPinAuthenticated) {
       await device.unlockDevice(DeviceSessionPinType.Main, {
         source: 'wallet-session-coordinator',
         reason: expectedPassphraseState ? 'session-recovery' : 'open-wallet',
         deviceOnly: true,
       });
-      mainPinSelected = true;
+      markWalletStatusRefreshed();
+      mainPinAuthenticated = true;
+      standardWalletSelected = true;
     }
   };
 
-  const selectStandardWallet = async () => {
-    // Main PIN authenticates the device; an empty host passphrase selects the standard derivation.
-    await selectMainPin();
+  const selectStandardWallet = async (forceMainPin = false) => {
     if (device.features?.passphraseProtection === true) {
-      await askDevicePassphrase(device, {
-        passphrase: '',
-        on_device: false,
-      });
+      // Main PIN authenticates the device; an empty host passphrase selects the standard derivation.
+      await selectMainPin();
+      await askDevicePassphrase(
+        device,
+        {
+          passphrase: '',
+          on_device: false,
+        },
+        options?.deriveCardano,
+        markWalletStatusRefreshed
+      );
+      standardWalletSelected = true;
+    } else if (!standardWalletSelected) {
+      // Without passphrase protection there is no empty-passphrase selector.
+      // An unlocked non-Attach-PIN device is already in the only available wallet context.
+      // Force Main PIN only when recovering from a mismatched cached standard session.
+      await selectMainPin(forceMainPin);
+      standardWalletSelected = true;
     }
   };
 
   if (readCurrentAttachPinSession) {
     const status = await requestProtocolV2DeviceStatus(device);
     device.updateProtocolV2Status(status);
+    markWalletStatusRefreshed();
     if (
       status.unlocked !== true ||
       status.passphrase_enabled !== true ||
@@ -297,10 +410,7 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
     }
-    response = await getDeviceSession(
-      device,
-      buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
-    );
+    response = await getDeviceSession(device, sessionGetRequest());
   } else if (options?.onlyMainPin) {
     expectedPassphraseState = cachedStandardSession?.passphraseState;
     if (cachedStandardSession) {
@@ -310,10 +420,9 @@ export async function getProtocolV2WalletSession(
         }
         response = await getDeviceSession(
           device,
-          buildDeviceSessionGetRequest({
+          sessionGetRequest({
             sessionId: cachedStandardSession.sessionId,
             expectedPassphraseState,
-            deriveCardano: options?.deriveCardano,
           })
         );
         resumed = true;
@@ -328,19 +437,15 @@ export async function getProtocolV2WalletSession(
 
     if (!response) {
       await selectStandardWallet();
-      response = await getDeviceSession(
-        device,
-        buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
-      );
+      response = await getDeviceSession(device, sessionGetRequest());
     }
   } else if (cachedSessionId && expectedPassphraseState) {
     try {
       response = await getDeviceSession(
         device,
-        buildDeviceSessionGetRequest({
+        sessionGetRequest({
           sessionId: cachedSessionId,
           expectedPassphraseState,
-          deriveCardano: options?.deriveCardano,
         })
       );
       resumed = true;
@@ -350,14 +455,18 @@ export async function getProtocolV2WalletSession(
         throw error;
       }
       resumed = false;
+      if (device.features?.unlockedAttachPin === true) {
+        // Locking invalidates the old handle, but Attach PIN already selected the wallet.
+        // Read the current session and validate its passphrase state below.
+        response = await getDeviceSession(device, sessionGetRequest());
+      }
     }
   } else if (expectedPassphraseState) {
     try {
       response = await getDeviceSession(
         device,
-        buildDeviceSessionGetRequest({
+        sessionGetRequest({
           expectedPassphraseState,
-          deriveCardano: options?.deriveCardano,
         })
       );
     } catch (error) {
@@ -372,7 +481,13 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
-    response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+    await lockAttachPinBeforePassphraseSelection();
+    response = await selectDeviceSession(
+      device,
+      expectedPassphraseState,
+      options?.deriveCardano,
+      markWalletStatusRefreshed
+    );
   }
 
   let { message } = response;
@@ -395,14 +510,17 @@ export async function getProtocolV2WalletSession(
     }
     if (options?.onlyMainPin) {
       device.clearStandardInternalState?.();
-      await selectStandardWallet();
-      response = await getDeviceSession(
-        device,
-        buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
-      );
+      await selectStandardWallet(true);
+      response = await getDeviceSession(device, sessionGetRequest());
     } else {
       device.clearInternalState();
-      response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+      await lockAttachPinBeforePassphraseSelection();
+      response = await selectDeviceSession(
+        device,
+        expectedPassphraseState,
+        options?.deriveCardano,
+        markWalletStatusRefreshed
+      );
     }
     message = response.message;
     try {
@@ -422,6 +540,54 @@ export async function getProtocolV2WalletSession(
     }
   }
 
+  // origin/dev generates Cardano on AskPassphrase, not Get. Empty host
+  // passphrase is the Attach PIN / standard-wallet secret. Hidden wallets
+  // still need a real passphrase Ask. Passphrase-off Get auto-requests Cardano.
+  if (options?.deriveCardano === true && !deviceSessionHasCardano(message)) {
+    if (options?.resumeOnly) {
+      device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+    }
+    resumed = false;
+    const previousAddress = message.btc_test_address;
+    if (sessionIsAttachPinWallet(response)) {
+      response = await askEmptyPassphraseAndGet({ deriveCardano: true, keepAttachPin: true });
+    } else if (device.features?.passphraseProtection === false) {
+      response = await getDeviceSession(device, buildDeviceSessionGetRequest());
+    } else if (options?.onlyMainPin) {
+      await selectMainPin();
+      response = await askEmptyPassphraseAndGet({ deriveCardano: true });
+    } else {
+      await lockAttachPinBeforePassphraseSelection();
+      response = await selectDeviceSession(
+        device,
+        expectedPassphraseState,
+        true,
+        markWalletStatusRefreshed
+      );
+    }
+    message = response.message;
+    try {
+      assertCompleteDeviceSession(message);
+    } catch (error) {
+      if (options?.onlyMainPin) {
+        device.clearStandardInternalState?.();
+      } else {
+        device.clearInternalState();
+      }
+      throw error;
+    }
+    if (previousAddress && previousAddress !== message.btc_test_address) {
+      await rejectMismatchedAttachPinWallet();
+      clearCurrentWalletSession();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+    }
+    if (!deviceSessionHasCardano(message)) {
+      clearCurrentWalletSession();
+      throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+    }
+  }
+
   const internalStateArgs = [
     true,
     message.btc_test_address,
@@ -436,9 +602,9 @@ export async function getProtocolV2WalletSession(
   }
 
   let unlockedAttachPin: boolean | undefined;
-  if (readCurrentAttachPinSession) {
+  if (readCurrentAttachPinSession || sessionIsAttachPinWallet(response)) {
     unlockedAttachPin = true;
-  } else if (mainPinSelected) {
+  } else if (mainPinAuthenticated) {
     unlockedAttachPin = false;
   }
 
@@ -447,6 +613,7 @@ export async function getProtocolV2WalletSession(
     newSession: message.session_id,
     unlockedAttachPin,
     resumed,
+    walletStatusRefreshed,
   };
 }
 

package/src/types/api/protocolV2.ts

@@ -1,6 +1,7 @@
 import type { CommonParams, Response } from '../params';
 import type { OnboardingStatus, Success } from '@onekeyfe/hd-transport';
 import type { DeviceRebootParams } from '../../api/protocol-v2/helpers';
+import type { UploadPortfolioParams } from '../../api/UploadPortfolio';
 import type {
   DeviceUploadWallpaperParams,
   DeviceUploadWallpaperResponse,
@@ -12,6 +13,7 @@ import type {
 
 // Re-export implementation parameter types as the single source of truth.
 export type { DeviceRebootParams, RebootTypeInput } from '../../api/protocol-v2/helpers';
+export type { UploadPortfolioParams } from '../../api/UploadPortfolio';
 export type {
   DeviceUploadWallpaperParams,
   DeviceUploadWallpaperResponse,
@@ -67,8 +69,5 @@ export declare function deviceUploadNft(
 
 export declare function uploadPortfolio(
   connectId: string,
-  params: {
-    packageBase64: string;
-    timeoutMs?: number | string;
-  }
+  params: UploadPortfolioParams
 ): Response<FileInfo & { portfolioUpdated: true }>;

package/src/types/api/solSignOffchainMessage.ts

@@ -15,6 +15,8 @@ export type SolSignOffchainMessageParams = {
   messageVersion?: SolanaOffChainMessageVersion;
   messageFormat?: SolanaOffChainMessageFormat;
   applicationDomainHex?: string;
+  /** 32-byte public keys encoded as hex, strictly sorted and unique. */
+  requiredSigners?: string[];
 };
 
 export declare function solSignOffchainMessage(

package/src/types/settings.ts

@@ -77,7 +77,8 @@ export type IProtocolV2Resources = {
 /** STM32 firmware config */
 export type IFirmwareReleaseInfo = {
   required: boolean;
-  url: string;
+  /** Legacy release artifact URL. Protocol V2 releases use component URLs. */
+  url?: string;
   /**
    * Firmware type (bitcoinonly or universal)
    * This field is not present in the remote config, but will be inferred from the firmware field name
@@ -106,7 +107,8 @@ export type IFirmwareReleaseInfo = {
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };
-  fingerprint: string;
+  /** Legacy release artifact SHA-256. Protocol V2 releases use component fingerprints. */
+  fingerprint?: string;
   expectedSize?: number;
   version: IVersionArray;
   changelog: {

package/src/utils/deviceFeaturesUtils.ts

@@ -110,6 +110,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     initSession?: boolean;
     deriveCardano?: boolean;
     rejectAttachPinForMainWallet?: boolean;
+    mainPinSelected?: boolean;
   }
 ) => {
   if (device.isProtocolV2()) {
@@ -127,6 +128,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
       onlyMainPin: options?.onlyMainPin,
       deriveCardano: options?.deriveCardano,
       rejectAttachPinForMainWallet: options?.rejectAttachPinForMainWallet,
+      mainPinSelected: options?.mainPinSelected,
     });
   }
 
@@ -194,6 +196,7 @@ export const getPassphraseState = async (
     initSession?: boolean;
     deriveCardano?: boolean;
     rejectAttachPinForMainWallet?: boolean;
+    mainPinSelected?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
@@ -216,6 +219,7 @@ export const getPassphraseState = async (
       onlyMainPin: options?.onlyMainPin,
       deriveCardano: options?.deriveCardano,
       rejectAttachPinForMainWallet: options?.rejectAttachPinForMainWallet,
+      mainPinSelected: options?.mainPinSelected,
     });
   }