@onekeyfe/hd-core 1.2.2-alpha.5 → 1.2.2-alpha.7

package/src/core/index.ts

@@ -2,7 +2,11 @@ import semver from 'semver';
 import EventEmitter from 'events';
 import {
   DeviceSessionPinType,
+  type LowlevelTransportSharedPlugin,
+  type OneKeyDeviceInfo,
+  type ProtocolType,
   TRANSPORT_EVENT,
+  type TransportDeviceDisconnectEvent,
   isProtocolV2LinkDisabledError,
 } from '@onekeyfe/hd-transport';
 import {
@@ -74,11 +78,6 @@ import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } fro
 import type { DeviceEvents, InitOptions, RunOptions } from '../device/Device';
 import type { SdkTracingContext } from '../utils/tracing';
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type {
-  LowlevelTransportSharedPlugin,
-  OneKeyDeviceInfo,
-  TransportDeviceDisconnectEvent,
-} from '@onekeyfe/hd-transport';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
@@ -1044,6 +1043,7 @@ async function connectDeviceForBle(
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
+      const connectProtocol = resolveBleConnectProtocol(method);
       // The deadline/abort guards are scoped to the desktop electron
       // transport: its IPC acquire is the only path with a proven
       // never-settling failure mode, while react-native/lowlevel acquire may
@@ -1055,13 +1055,13 @@ async function connectDeviceForBle(
         throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
       }
       if (!useAcquireGuards) {
-        await device.acquire(method.payload.connectProtocol, {
+        await device.acquire(connectProtocol, {
           forceProtocolDetection: method.payload.forceProtocolDetection,
         });
       } else {
         try {
           await raceBleAcquire(
-            device.acquire(method.payload.connectProtocol, {
+            device.acquire(connectProtocol, {
               forceProtocolDetection: method.payload.forceProtocolDetection,
             }),
             abortSignal
@@ -1127,6 +1127,14 @@ async function connectDeviceForBle(
   }
 }
 
+export function resolveBleConnectProtocol(method: BaseMethod): ProtocolType | undefined {
+  if (method.payload.connectProtocol === 'V1' || method.payload.connectProtocol === 'V2') {
+    return method.payload.connectProtocol;
+  }
+  const supportedProtocols = method.getSupportedProtocols();
+  return supportedProtocols.length === 1 && supportedProtocols[0] === 'V2' ? 'V2' : undefined;
+}
+
 type IPollFn<T> = (time?: number) => T;
 // eslint-disable-next-line @typescript-eslint/require-await
 const ensureConnected = async (
@@ -1333,7 +1341,10 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       );
       // Abort before rejecting: rejectRequest releases the task and would make
       // its AbortController unreachable to an in-flight method loop.
-      requestQueue.abortRequestsByConnectId(connectId);
+      // This branch rejects every queued request below. Abort the same set first so
+      // methods whose physical connectId is selected internally (for example
+      // Desktop WebUSB firmwareUpdateV4) cannot keep retrying after rejection.
+      requestQueue.abortAllRequests();
       const canceledDevices: Device[] = [];
       const interruptDevice = (device: Device | undefined, deviceConnectId: string) => {
         if (!device || canceledDevices.includes(device)) {

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

@@ -12852,36 +12852,57 @@
       },
       "reserved": [[2, 2], "placeholder"]
     },
-    "ViewData": {
+    "ViewContentPreview": {
       "fields": {
+        "content_key": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
         "preview": {
           "rule": "required",
           "type": "bytes",
-          "id": 1
+          "id": 2
         },
         "total_bytes": {
-          "rule": "required",
           "type": "uint32",
-          "id": 2
+          "id": 3
         }
       }
     },
-    "ViewDataPage": {
+    "ViewContentEntry": {
       "fields": {
-        "chunk": {
+        "entry_key": {
           "rule": "required",
-          "type": "bytes",
+          "type": "uint32",
           "id": 1
         },
+        "value": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "ViewContentPage": {
+      "fields": {
         "page_index": {
           "rule": "required",
           "type": "uint32",
-          "id": 2
+          "id": 1
         },
         "page_count": {
           "rule": "required",
           "type": "uint32",
+          "id": 2
+        },
+        "chunk": {
+          "type": "bytes",
           "id": 3
+        },
+        "entry": {
+          "type": "ViewContentEntry",
+          "id": 4
         }
       }
     },
@@ -12940,8 +12961,8 @@
           "type": "string",
           "id": 9
         },
-        "data": {
-          "type": "ViewData",
+        "content": {
+          "type": "ViewContentPreview",
           "id": 10
         },
         "custom_field": {
@@ -12965,6 +12986,10 @@
         "text_arg": {
           "type": "string",
           "id": 3
+        },
+        "cancellable": {
+          "type": "bool",
+          "id": 4
         }
       }
     },
@@ -13003,6 +13028,10 @@
         "chain_id": {
           "type": "uint32",
           "id": 8
+        },
+        "content": {
+          "type": "ViewContentPreview",
+          "id": 9
         }
       }
     },

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

@@ -76,9 +76,7 @@ const deviceSessionHasCardano = (message: { seed_domains?: DeviceSessionSeedDoma
   Array.isArray(message.seed_domains) &&
   message.seed_domains.includes(DeviceSessionSeedDomain.SeedDomain_Cardano);
 
-// AskPassphrase.seed_domains selects which seeds to generate. DeviceSessionGet
-// only resumes or reads the current session; firmware rejects unknown Get
-// fields, including leftover seed_domains.
+// origin/dev Get is read/resume only. Seed generation lives on AskPassphrase.
 const buildDeviceSessionGetRequest = ({
   sessionId,
   expectedPassphraseState,
@@ -171,7 +169,22 @@ const selectDeviceSession = async (
       interaction: attachPinInteraction,
     });
     onStatusRefreshed?.();
-    return getDeviceSession(device, buildDeviceSessionGetRequest());
+    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) {
@@ -221,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) {
@@ -271,6 +288,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();
@@ -292,6 +341,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();
   }
@@ -342,7 +404,7 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
     }
-    response = await getDeviceSession(device, buildDeviceSessionGetRequest());
+    response = await getDeviceSession(device, sessionGetRequest());
   } else if (options?.onlyMainPin) {
     expectedPassphraseState = cachedStandardSession?.passphraseState;
     if (cachedStandardSession) {
@@ -352,7 +414,7 @@ export async function getProtocolV2WalletSession(
         }
         response = await getDeviceSession(
           device,
-          buildDeviceSessionGetRequest({
+          sessionGetRequest({
             sessionId: cachedStandardSession.sessionId,
             expectedPassphraseState,
           })
@@ -369,13 +431,13 @@ export async function getProtocolV2WalletSession(
 
     if (!response) {
       await selectStandardWallet();
-      response = await getDeviceSession(device, buildDeviceSessionGetRequest());
+      response = await getDeviceSession(device, sessionGetRequest());
     }
   } else if (cachedSessionId && expectedPassphraseState) {
     try {
       response = await getDeviceSession(
         device,
-        buildDeviceSessionGetRequest({
+        sessionGetRequest({
           sessionId: cachedSessionId,
           expectedPassphraseState,
         })
@@ -392,7 +454,7 @@ export async function getProtocolV2WalletSession(
     try {
       response = await getDeviceSession(
         device,
-        buildDeviceSessionGetRequest({
+        sessionGetRequest({
           expectedPassphraseState,
         })
       );
@@ -408,6 +470,7 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
+    await lockAttachPinBeforePassphraseSelection();
     response = await selectDeviceSession(
       device,
       expectedPassphraseState,
@@ -437,9 +500,10 @@ export async function getProtocolV2WalletSession(
     if (options?.onlyMainPin) {
       device.clearStandardInternalState?.();
       await selectStandardWallet();
-      response = await getDeviceSession(device, buildDeviceSessionGetRequest());
+      response = await getDeviceSession(device, sessionGetRequest());
     } else {
       device.clearInternalState();
+      await lockAttachPinBeforePassphraseSelection();
       response = await selectDeviceSession(
         device,
         expectedPassphraseState,
@@ -465,18 +529,25 @@ export async function getProtocolV2WalletSession(
     }
   }
 
-  // DeviceSession.seed_domains reports what the SE already generated. Get
-  // cannot add Cardano, so a Cardano call on a Standard-only session must Ask again.
+  // 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;
-    if (options?.onlyMainPin) {
-      await selectStandardWallet();
+    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,
@@ -495,6 +566,15 @@ export async function getProtocolV2WalletSession(
       }
       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 = [
@@ -511,7 +591,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 = (() => {