@onekeyfe/hd-core 1.2.2-alpha.1 → 1.2.2-alpha.10

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

@@ -63,32 +63,41 @@ 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,
+  requestPayload: Omit<DeviceSessionAskPassphrase, 'seed_domains'>,
+  deriveCardano?: boolean,
   onStatusRefreshed?: () => void
 ) => {
-  await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', requestPayload);
+  await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', {
+    ...requestPayload,
+    seed_domains: buildDeviceSessionSeedDomains(deriveCardano),
+  });
   await refreshProtocolV2DeviceStatus(device);
   onStatusRefreshed?.();
 };
@@ -160,7 +169,22 @@ const selectDeviceSession = async (
       interaction: attachPinInteraction,
     });
     onStatusRefreshed?.();
-    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+    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) {
@@ -170,9 +194,10 @@ const selectDeviceSession = async (
         passphrase: hostPassphrase,
         on_device: false,
       },
+      deriveCardano,
       onStatusRefreshed
     );
-    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+    return getDeviceSession(device, buildDeviceSessionGetRequest());
   }
 
   const passphraseOnDeviceInteraction = device.createProtocolV2UiPhaseMetadata?.(
@@ -183,8 +208,8 @@ const selectDeviceSession = async (
     ...metadata,
     ...(passphraseOnDeviceInteraction ? { interaction: passphraseOnDeviceInteraction } : {}),
   });
-  await askDevicePassphrase(device, { on_device: true }, onStatusRefreshed);
-  return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+  await askDevicePassphrase(device, { on_device: true }, deriveCardano, onStatusRefreshed);
+  return getDeviceSession(device, buildDeviceSessionGetRequest());
 };
 
 export async function getProtocolV2WalletSession(
@@ -209,6 +234,10 @@ export async function getProtocolV2WalletSession(
   const forceWalletSelection =
     options?.forceWalletSelection === true || options?.initSession === true;
   const readCurrentAttachPinSession = options?.readCurrentAttachPinSession === true;
+  const sessionIsAttachPinWallet = (session?: { viaAttachPin?: boolean }) =>
+    readCurrentAttachPinSession ||
+    session?.viaAttachPin === true ||
+    device.features?.unlockedAttachPin === true;
 
   if (forceWalletSelection) {
     if (options.onlyMainPin) {
@@ -244,6 +273,10 @@ export async function getProtocolV2WalletSession(
   const markWalletStatusRefreshed = () => {
     walletStatusRefreshed = true;
   };
+  if (options?.onlyMainPin && options.mainPinSelected !== true) {
+    await refreshProtocolV2DeviceStatus(device);
+    markWalletStatusRefreshed();
+  }
   let mainPinAuthenticated =
     options?.mainPinSelected === true ||
     (options?.onlyMainPin === true &&
@@ -259,6 +292,38 @@ 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();
@@ -280,6 +345,19 @@ 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();
   }
@@ -297,7 +375,7 @@ export async function getProtocolV2WalletSession(
     }
   };
 
-  const selectStandardWallet = async () => {
+  const selectStandardWallet = async (forceMainPin = false) => {
     if (device.features?.passphraseProtection === true) {
       // Main PIN authenticates the device; an empty host passphrase selects the standard derivation.
       await selectMainPin();
@@ -307,13 +385,16 @@ export async function getProtocolV2WalletSession(
           passphrase: '',
           on_device: false,
         },
+        options?.deriveCardano,
         markWalletStatusRefreshed
       );
       standardWalletSelected = true;
     } else if (!standardWalletSelected) {
       // Without passphrase protection there is no empty-passphrase selector.
-      // Main PIN selection is the only authoritative switch back to the standard wallet.
-      await selectMainPin(true);
+      // 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;
     }
   };
 
@@ -329,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) {
@@ -342,10 +420,9 @@ export async function getProtocolV2WalletSession(
         }
         response = await getDeviceSession(
           device,
-          buildDeviceSessionGetRequest({
+          sessionGetRequest({
             sessionId: cachedStandardSession.sessionId,
             expectedPassphraseState,
-            deriveCardano: options?.deriveCardano,
           })
         );
         resumed = true;
@@ -360,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;
@@ -387,9 +460,8 @@ export async function getProtocolV2WalletSession(
     try {
       response = await getDeviceSession(
         device,
-        buildDeviceSessionGetRequest({
+        sessionGetRequest({
           expectedPassphraseState,
-          deriveCardano: options?.deriveCardano,
         })
       );
     } catch (error) {
@@ -404,6 +476,7 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
+    await lockAttachPinBeforePassphraseSelection();
     response = await selectDeviceSession(
       device,
       expectedPassphraseState,
@@ -432,13 +505,11 @@ 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();
+      await lockAttachPinBeforePassphraseSelection();
       response = await selectDeviceSession(
         device,
         expectedPassphraseState,
@@ -464,6 +535,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,
@@ -478,7 +597,7 @@ export async function getProtocolV2WalletSession(
   }
 
   let unlockedAttachPin: boolean | undefined;
-  if (readCurrentAttachPinSession) {
+  if (readCurrentAttachPinSession || sessionIsAttachPinWallet(response)) {
     unlockedAttachPin = true;
   } else if (mainPinAuthenticated) {
     unlockedAttachPin = false;

package/src/utils/pro2HostAssetPackage.ts

@@ -37,7 +37,9 @@ const ARCHIVE_ENTRY_SIZE = 296;
 const ARCHIVE_ENTRY_NAME_MAX_LENGTH = 255;
 const ARCHIVE_COMPRESS_LZ4_BLOCKED = 1;
 const ARCHIVE_ALIGNMENT = 4;
-const LZ4_BLOCK_SIZE_LOG2 = 12;
+const LZ4_PREFERRED_BLOCK_SIZE_LOG2 = 14;
+const LZ4_FALLBACK_BLOCK_SIZE_LOG2 = 13;
+const LZ4_COMPRESSED_BLOCK_SIZE_MAX = 1 << 14;
 
 export type Pro2HostAssetPackageEntry = {
   name: string;
@@ -101,7 +103,7 @@ const LZ4_MAX_OFFSET = 0xffff;
 const LZ4_LENGTH_MASK = 15;
 const LZ4_HASH_LOG = 16;
 const LZ4_HASH_MULTIPLIER = 2654435761;
-const LZ4_SKIP_TRIGGER = 6;
+const LZ4_MAX_SEARCH_DEPTH = 64;
 
 function writeExtendedLength(output: Uint8Array, offset: number, length: number): number {
   let remaining = length;
@@ -178,7 +180,11 @@ function emitLastLiterals(
   return copyBytes(output, nextOffset, input, anchor, literalLength);
 }
 
-function compressRawLz4Block(input: Uint8Array, hashTable: Uint32Array): Uint8Array {
+function compressRawLz4Block(
+  input: Uint8Array,
+  hashTable: Uint32Array,
+  matchChain: Int32Array
+): Uint8Array {
   const output = new Uint8Array(input.byteLength + Math.floor(input.byteLength / 255) + 16);
   const inputView = new DataView(input.buffer, input.byteOffset, input.byteLength);
   const matchFindLimit = input.byteLength - LZ4_MATCH_FIND_LIMIT;
@@ -186,42 +192,65 @@ function compressRawLz4Block(input: Uint8Array, hashTable: Uint32Array): Uint8Ar
   let anchor = 0;
   let inputOffset = 0;
   let outputOffset = 0;
-  let searchMatchCount = 1 << LZ4_SKIP_TRIGGER;
 
   hashTable.fill(0);
   while (inputOffset < matchFindLimit) {
     const sequence = inputView.getUint32(inputOffset, true);
     const hash = Math.imul(sequence, LZ4_HASH_MULTIPLIER) >>> (32 - LZ4_HASH_LOG);
-    const candidate = hashTable[hash] - 1;
+    let candidate = hashTable[hash] - 1;
+    matchChain[inputOffset] = candidate;
     hashTable[hash] = inputOffset + 1;
 
-    const hasMatch = !(
-      candidate < 0 ||
-      inputOffset - candidate > LZ4_MAX_OFFSET ||
-      inputView.getUint32(candidate, true) !== sequence
-    );
-    if (!hasMatch) {
-      inputOffset += searchMatchCount >> LZ4_SKIP_TRIGGER;
-      searchMatchCount += 1;
-    } else {
-      searchMatchCount = 1 << LZ4_SKIP_TRIGGER;
-      let matchEnd = inputOffset + LZ4_MIN_MATCH;
-      let reference = candidate + LZ4_MIN_MATCH;
-      while (matchEnd < matchExtendLimit && input[matchEnd] === input[reference]) {
-        matchEnd += 1;
-        reference += 1;
+    let bestCandidate = -1;
+    let bestMatchEnd = inputOffset;
+    let searchDepth = 0;
+    while (
+      candidate >= 0 &&
+      inputOffset - candidate <= LZ4_MAX_OFFSET &&
+      searchDepth < LZ4_MAX_SEARCH_DEPTH
+    ) {
+      if (inputView.getUint32(candidate, true) === sequence) {
+        let matchEnd = inputOffset + LZ4_MIN_MATCH;
+        let reference = candidate + LZ4_MIN_MATCH;
+        while (matchEnd < matchExtendLimit && input[matchEnd] === input[reference]) {
+          matchEnd += 1;
+          reference += 1;
+        }
+        if (matchEnd > bestMatchEnd) {
+          bestCandidate = candidate;
+          bestMatchEnd = matchEnd;
+        }
       }
+      candidate = matchChain[candidate];
+      searchDepth += 1;
+    }
+
+    if (bestCandidate < 0) {
+      inputOffset += 1;
+    } else {
+      const matchStart = inputOffset;
       outputOffset = emitSequence(
         output,
         outputOffset,
         input,
         anchor,
         inputOffset - anchor,
-        inputOffset - candidate,
-        matchEnd - inputOffset - LZ4_MIN_MATCH
+        inputOffset - bestCandidate,
+        bestMatchEnd - inputOffset - LZ4_MIN_MATCH
       );
-      inputOffset = matchEnd;
+      inputOffset = bestMatchEnd;
       anchor = inputOffset;
+
+      for (
+        let skippedOffset = matchStart + 1;
+        skippedOffset < inputOffset && skippedOffset < matchFindLimit;
+        skippedOffset += 1
+      ) {
+        const skippedSequence = inputView.getUint32(skippedOffset, true);
+        const skippedHash = Math.imul(skippedSequence, LZ4_HASH_MULTIPLIER) >>> (32 - LZ4_HASH_LOG);
+        matchChain[skippedOffset] = hashTable[skippedHash] - 1;
+        hashTable[skippedHash] = skippedOffset + 1;
+      }
     }
   }
 
@@ -234,27 +263,44 @@ function compressRawLz4Block(input: Uint8Array, hashTable: Uint32Array): Uint8Ar
 // The archive stores an 8-byte descriptor, one compressed-size value per
 // block, then the concatenated raw blocks. Blocks are independent so firmware
 // can validate and decompress them with bounded memory.
-function encodeLz4Blocked(data: Uint8Array): Uint8Array {
-  const blockSize = 1 << LZ4_BLOCK_SIZE_LOG2;
+function encodeLz4BlockedWithBlockSize(
+  data: Uint8Array,
+  blockSizeLog2: number
+): Uint8Array | undefined {
+  const blockSize = 1 << blockSizeLog2;
   const blockCount = Math.ceil(data.byteLength / blockSize);
   const hashTable = new Uint32Array(1 << LZ4_HASH_LOG);
+  const matchChain = new Int32Array(blockSize);
   const blocks: Uint8Array[] = [];
   const header = new Uint8Array(8 + blockCount * 4);
   const headerView = new DataView(header.buffer);
   headerView.setUint16(0, blockCount, true);
-  headerView.setUint16(2, LZ4_BLOCK_SIZE_LOG2, true);
+  headerView.setUint16(2, blockSizeLog2, true);
 
   for (let index = 0; index < blockCount; index += 1) {
     const block = compressRawLz4Block(
       data.subarray(index * blockSize, Math.min((index + 1) * blockSize, data.byteLength)),
-      hashTable
+      hashTable,
+      matchChain
     );
+    if (block.byteLength > LZ4_COMPRESSED_BLOCK_SIZE_MAX) return undefined;
     headerView.setUint32(8 + index * 4, block.byteLength, true);
     blocks.push(block);
   }
   return concatBytes([header, ...blocks]);
 }
 
+function encodeLz4Blocked(data: Uint8Array): Uint8Array {
+  const preferred = encodeLz4BlockedWithBlockSize(data, LZ4_PREFERRED_BLOCK_SIZE_LOG2);
+  if (preferred) return preferred;
+
+  const fallback = encodeLz4BlockedWithBlockSize(data, LZ4_FALLBACK_BLOCK_SIZE_LOG2);
+  if (!fallback) {
+    throw new Error('Pro2 host asset package LZ4 block exceeds the firmware buffer limit.');
+  }
+  return fallback;
+}
+
 // OKAR integrity helpers
 // ----------------------
 const CRC32_TABLE = (() => {