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

package/src/data/messages/messages-protocol-v2.json

@@ -12244,11 +12244,26 @@
         "DeviceSessionError_Busy": 5
       }
     },
+    "DeviceSessionSeedDomain": {
+      "values": {
+        "SeedDomain_Standard": 1,
+        "SeedDomain_Cardano": 2
+      }
+    },
     "DeviceSessionGet": {
       "fields": {
         "session_id": {
           "type": "bytes",
           "id": 1
+        },
+        "btc_test_address": {
+          "type": "string",
+          "id": 2
+        },
+        "seed_domains": {
+          "rule": "repeated",
+          "type": "DeviceSessionSeedDomain",
+          "id": 3
         }
       }
     },

package/src/device/Device.ts

@@ -1644,18 +1644,28 @@ export class Device extends EventEmitter {
     });
   }
 
-  finishProtocolV2UiInteraction(outcome: HardwareUiInteractionMeta['outcome'] = 'succeeded') {
+  finishProtocolV2UiInteraction(
+    outcome?: HardwareUiInteractionMeta['outcome'],
+    options?: { ensureMetadata?: boolean }
+  ) {
     const interaction = this.protocolV2UiInteraction;
-    if (!interaction?.opened) {
+    if (!interaction || (!interaction.opened && !options?.ensureMetadata)) {
       this.protocolV2UiInteraction = undefined;
       return undefined;
     }
 
     const phaseId = `${interaction.interactionId}:phase-${Math.max(interaction.phaseCounter, 1)}`;
-    const metadata = this.createProtocolV2UiPhaseMetadata('processing', 'finish', {
+    interaction.opened = true;
+    interaction.sequence += 1;
+    const metadata: HardwareUiInteractionMeta = {
+      interactionId: interaction.interactionId,
       phaseId,
-      outcome,
-    });
+      sequence: interaction.sequence,
+      phase: 'processing',
+      transition: 'finish',
+      outcome: outcome ?? 'succeeded',
+      protocol: 'V2',
+    };
     this.protocolV2UiInteraction = undefined;
     return metadata;
   }

package/src/events/ui-request.ts

@@ -64,6 +64,7 @@ export type HardwareUiInteractionMeta = {
   transition: 'start' | 'complete' | 'finish';
   outcome?: 'submitted' | 'succeeded' | 'failed' | 'cancelled' | 'disconnected';
   protocol: 'V2';
+  device?: Device;
 };
 
 export type ProtocolV2UiEventMetadata = {

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

@@ -203,20 +203,34 @@ export class ProtocolV2UiInteractionCoordinator {
     this.enterMethodInteraction(this.methodInteraction);
   }
 
-  close() {
+  close(
+    options: {
+      ensureOperationClose?: boolean;
+      protocolV2Operation?: boolean;
+    } = {}
+  ): boolean {
     if (
-      !this.device.isProtocolV2() ||
-      (!this.opened && !this.device.hasOpenProtocolV2UiInteraction?.()) ||
+      (!options.protocolV2Operation && !this.device.isProtocolV2()) ||
+      (!options.ensureOperationClose &&
+        !this.opened &&
+        !this.device.hasOpenProtocolV2UiInteraction?.()) ||
       this.closed
     )
-      return;
+      return false;
     this.closed = true;
-    const interaction = this.device.finishProtocolV2UiInteraction?.();
+    const interaction = this.device.finishProtocolV2UiInteraction?.('succeeded', {
+      ensureMetadata: options.ensureOperationClose,
+    });
+    const device = this.device.toMessageObject();
     this.postMessage(
       interaction
-        ? createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW, interaction)
+        ? createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW, {
+            ...interaction,
+            ...(device ? { device } : {}),
+          })
         : createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW)
     );
+    return true;
   }
 
   private emit(

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

@@ -80,7 +80,14 @@ export async function runMethodWithUnlockPolicy<T = unknown>(
 
     await afterStatusBeforeUnlock?.();
 
-    if (!status.unlocked) {
+    const isStandardWalletRequest =
+      method.unlockPolicy !== 'unlock-before-run' &&
+      method.useDevicePassphraseState &&
+      method.payload?.useEmptyPassphrase === true;
+    const standardWalletSessionOwnsUnlock =
+      isStandardWalletRequest && status.passphraseProtection === true;
+
+    if (!status.unlocked && !standardWalletSessionOwnsUnlock) {
       const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
         ? uiCoordinator.enterUnlockInteraction(method.name)
         : undefined;

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';
@@ -63,12 +63,36 @@ const negotiateEventlessWalletSession = async (device: Device) => {
 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,
@@ -129,7 +153,7 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
       emitUiEvent: false,
       interaction: attachPinInteraction,
     });
-    return getDeviceSession(device, {});
+    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
   }
 
   if (hasHostPassphrase) {
@@ -137,7 +161,7 @@ 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, {
@@ -145,7 +169,7 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
     ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
   });
   await askDevicePassphrase(device, { on_device: true });
-  return getDeviceSession(device, {});
+  return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
 };
 
 export async function getProtocolV2WalletSession(
@@ -191,7 +215,10 @@ export async function getProtocolV2WalletSession(
       : undefined;
   let response;
   let resumed = false;
-  let mainWalletSelected = false;
+  let mainPinSelected =
+    options?.onlyMainPin === true &&
+    device.features?.unlocked === true &&
+    device.features?.unlockedAttachPin === false;
 
   const clearCurrentWalletSession = () => {
     if (options?.onlyMainPin) {
@@ -216,14 +243,25 @@ export async function getProtocolV2WalletSession(
     throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
   };
 
-  const selectMainWallet = async (force = false) => {
-    if (force || !mainWalletSelected) {
+  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,
       });
-      mainWalletSelected = 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,
+      });
     }
   };
 
@@ -232,11 +270,16 @@ export async function getProtocolV2WalletSession(
     if (cachedStandardSession) {
       try {
         if (options?.selectMainWalletBeforeRestore) {
-          await selectMainWallet();
+          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?.();
@@ -248,14 +291,22 @@ export async function getProtocolV2WalletSession(
     }
 
     if (!response) {
-      await selectMainWallet();
-      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();
@@ -266,7 +317,13 @@ export async function getProtocolV2WalletSession(
     }
   } else if (expectedPassphraseState) {
     try {
-      response = await getDeviceSession(device, {});
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({
+          expectedPassphraseState,
+          deriveCardano: options?.deriveCardano,
+        })
+      );
     } catch (error) {
       if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
         throw error;
@@ -279,7 +336,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;
@@ -302,11 +359,14 @@ export async function getProtocolV2WalletSession(
     }
     if (options?.onlyMainPin) {
       device.clearStandardInternalState?.();
-      await selectMainWallet(true);
-      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 {
@@ -342,7 +402,7 @@ export async function getProtocolV2WalletSession(
   return {
     passphraseState: message.btc_test_address,
     newSession: message.session_id,
-    unlockedAttachPin: mainWalletSelected ? false : undefined,
+    unlockedAttachPin: mainPinSelected ? false : undefined,
     resumed,
   };
 }

package/src/utils/pro2Nft.ts

@@ -14,6 +14,7 @@ export const PRO2_NFT_DEFAULT_PACE_MS = 20;
 export const PRO2_NFT_DEFAULT_TIMEOUT_MS = 15_000;
 export const PRO2_NFT_MIN_CHUNK_SIZE = 64;
 export const PRO2_NFT_MAX_CHUNK_SIZE = 2048;
+export const PRO2_NFT_MAX_ITEMS = 10;
 
 export type Pro2NftImage = {
   width: number;
@@ -28,6 +29,56 @@ export type Pro2NftBundle = {
   metadata: Uint8Array;
 };
 
+const PRO2_NFT_BASENAME_PATTERN = /^nft-[0-9a-f]{8}-[1-9][0-9]*$/;
+
+type Pro2NftFileType = 'image' | 'thumbnail' | 'metadata';
+
+function parsePro2NftFile(listedPath: string):
+  | {
+      basename: string;
+      fileType: Pro2NftFileType;
+    }
+  | undefined {
+  const filename = listedPath.trim().split('/').at(-1);
+  if (!filename) return undefined;
+
+  let basename: string | undefined;
+  let fileType: Pro2NftFileType | undefined;
+  if (filename.endsWith('_m.bin')) {
+    basename = filename.slice(0, -'_m.bin'.length);
+    fileType = 'thumbnail';
+  } else if (filename.endsWith('.json')) {
+    basename = filename.slice(0, -'.json'.length);
+    fileType = 'metadata';
+  } else if (filename.endsWith('.bin')) {
+    basename = filename.slice(0, -'.bin'.length);
+    fileType = 'image';
+  }
+
+  return basename && fileType && PRO2_NFT_BASENAME_PATTERN.test(basename)
+    ? { basename, fileType }
+    : undefined;
+}
+
+export function getCompletePro2NftBasenames(childFiles?: string): Set<string> {
+  const filesByBasename = new Map<string, Set<Pro2NftFileType>>();
+
+  for (const listedPath of childFiles?.split('\n') ?? []) {
+    const file = parsePro2NftFile(listedPath);
+    if (file) {
+      const fileTypes = filesByBasename.get(file.basename) ?? new Set<Pro2NftFileType>();
+      fileTypes.add(file.fileType);
+      filesByBasename.set(file.basename, fileTypes);
+    }
+  }
+
+  return new Set(
+    [...filesByBasename.entries()]
+      .filter(([, fileTypes]) => fileTypes.size === 3)
+      .map(([basename]) => basename)
+  );
+}
+
 function utf8Length(value: string): number {
   return new TextEncoder().encode(value).byteLength;
 }