@onekeyfe/hd-core 1.2.2-alpha.9 → 1.2.2

package/src/api/OpenWalletSession.ts

@@ -1,7 +1,6 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
-import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
 import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';
@@ -13,16 +12,6 @@ import type {
   OpenWalletSessionPayload,
 } from '../types/api/openWalletSession';
 
-const requiredString = (value: unknown, name: string) => {
-  if (value === undefined || value === null) {
-    throw invalidParameter(`Missing required parameter: ${name}`);
-  }
-  if (typeof value !== 'string' || !value.trim()) {
-    throw invalidParameter(`Parameter [${name}] must be a non-empty string.`);
-  }
-  return value.trim();
-};
-
 const wasResumed = (session: unknown) =>
   !!session &&
   typeof session === 'object' &&
@@ -53,34 +42,21 @@ const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionPar
   }
   if (
     payload.mode !== OpenWalletSessionMode.Standard &&
-    payload.mode !== OpenWalletSessionMode.SelectHidden &&
-    payload.mode !== OpenWalletSessionMode.ResumeHidden
+    payload.mode !== OpenWalletSessionMode.SelectHidden
   ) {
-    throw invalidParameter(
-      'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
-    );
+    throw invalidParameter('Parameter [mode] must be one of standard or select-hidden.');
   }
   if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
     throw invalidParameter(
       'Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.'
     );
   }
-  if (
-    payload.mode === OpenWalletSessionMode.Standard ||
-    payload.mode === OpenWalletSessionMode.SelectHidden
-  ) {
-    if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
-      throw invalidParameter(
-        'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
-      );
-    }
-    return { mode: payload.mode };
+  if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
+    throw invalidParameter(
+      'Parameters [deviceId] and [passphraseState] are not supported by openWalletSession. Pass passphraseState on later address and signing calls.'
+    );
   }
-  return {
-    mode: OpenWalletSessionMode.ResumeHidden,
-    deviceId: requiredString(payload.deviceId, 'deviceId'),
-    passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
-  };
+  return { mode: payload.mode };
 };
 
 export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParams> {
@@ -196,52 +172,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       };
     }
 
-    if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
-      if (isProtocolV2) {
-        await ensureProtocolV2WalletStatus();
-        const refreshedDeviceId = requireDeviceId();
-        if (refreshedDeviceId !== this.params.deviceId) {
-          deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
-          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-        }
-      } else if (requireDeviceId() !== this.params.deviceId) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-      }
-      this.device.passphraseState = this.params.passphraseState;
-      const cachedSessionId = deviceWalletSessionStore.get(
-        this.params.deviceId,
-        this.params.passphraseState
-      );
-      if (!cachedSessionId && !isProtocolV2) {
-        throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
-      }
-      if (!isProtocolV2) {
-        await this.device.initialize({
-          deviceId: this.params.deviceId,
-          passphraseState: this.params.passphraseState,
-        });
-      }
-      const session = isProtocolV2
-        ? await getProtocolV2WalletSession(this.device, {
-            expectedPassphraseState: this.params.passphraseState,
-          })
-        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-            expectPassphraseState: this.params.passphraseState,
-          });
-      const deviceId = requireDeviceId();
-      if (session.passphraseState !== this.params.passphraseState) {
-        this.device.clearInternalState();
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
-      }
-      return {
-        protocol,
-        walletType: 'hidden',
-        deviceId,
-        ...requireHiddenWalletResponse(session),
-        resumed: wasResumed(session) || (!isProtocolV2 && session.newSession === cachedSessionId),
-      };
-    }
-
     this.device.passphraseState = undefined;
     const walletStatus = await ensureProtocolV2WalletStatus();
     if (isProtocolV2 && walletStatus.status.passphraseProtection !== true) {

package/src/api/SearchDevices.ts

@@ -1,4 +1,4 @@
-import { canonicalizePro2BleAdvertisementName } from '@onekeyfe/hd-shared';
+import { EDeviceType, canonicalizePro2BleAdvertisementName } from '@onekeyfe/hd-shared';
 
 import { BaseMethod } from './BaseMethod';
 import TransportManager from '../data-manager/TransportManager';
@@ -6,10 +6,80 @@ import { DataManager } from '../data-manager';
 import { LoggerNames, getDeviceTypeByBleName, getLogger } from '../utils';
 import { DevicePool } from '../device/DevicePool';
 
+import type { SearchDevice } from '../types/device';
 import type DeviceConnector from '../device/DeviceConnector';
+import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import type { Device } from '../device/Device';
 
 const Log = getLogger(LoggerNames.DevicePool);
 
+type RequestQueueLookup = {
+  getRequestTasksIdByConnectId: (connectId: string) => number[];
+  getTask: (requestId: number) => { method: { device?: Device } } | undefined;
+};
+
+const getDescriptorKeys = (descriptor: DeviceDescriptor) =>
+  [descriptor.path, descriptor.id].filter(
+    (key): key is string => typeof key === 'string' && key.length > 0
+  );
+
+const isOwnedByActiveWebUsbRequest = (
+  descriptor: DeviceDescriptor,
+  requestQueue?: RequestQueueLookup
+) => {
+  if (!requestQueue) return false;
+  return getDescriptorKeys(descriptor).some(
+    key => requestQueue.getRequestTasksIdByConnectId(key).length > 0
+  );
+};
+
+const getUsbHandle = (descriptor?: DeviceDescriptor) =>
+  (descriptor as { device?: unknown } | undefined)?.device;
+
+const getOwningRequestDevice = (
+  descriptor: DeviceDescriptor,
+  requestQueue?: RequestQueueLookup
+) => {
+  if (!requestQueue) return undefined;
+  const usbHandle = getUsbHandle(descriptor);
+  // A path alone can be shared (the all-zero bootloader path, a synthesized serial-less
+  // path), so the owner's identity is only reported for the USB handle it actually bound.
+  if (usbHandle === undefined) return undefined;
+  for (const key of getDescriptorKeys(descriptor)) {
+    for (const requestId of requestQueue.getRequestTasksIdByConnectId(key)) {
+      const device = requestQueue.getTask(requestId)?.method.device;
+      if (
+        device?.features &&
+        (device.mainId === key || device.originalDescriptor?.path === key) &&
+        getUsbHandle(device.originalDescriptor) === usbHandle
+      ) {
+        return device;
+      }
+    }
+  }
+  return undefined;
+};
+
+// A USB path is a routing key (the USB serial, a synthesized usb-vid-pid-name, or the
+// bootloader placeholder), not a hardware identity, so it never fills uuid/serialNo.
+const toSearchDeviceFromDescriptor = (descriptor: DeviceDescriptor): SearchDevice => {
+  const connectId = descriptor.path || descriptor.id || null;
+  return {
+    connectId,
+    uuid: '',
+    serialNo: null,
+    deviceId: null,
+    deviceType: EDeviceType.Unknown,
+    name: descriptor.name || connectId || '',
+    commType: descriptor.commType,
+  };
+};
+
+const toSearchDevice = (device: Device): SearchDevice | null => {
+  const message = device.toMessageObject();
+  return message ? (message as SearchDevice) : null;
+};
+
 export default class SearchDevices extends BaseMethod {
   connector?: DeviceConnector;
 
@@ -19,19 +89,31 @@ export default class SearchDevices extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  async run() {
-    await TransportManager.configure();
+  async run(): Promise<SearchDevice[]> {
+    const env = DataManager.getSettings('env');
+    const isWebUsb = env === 'webusb' || env === 'desktop-webusb';
+    const requestQueue = this.context?.requestQueue;
+    const hasActiveWebUsbRequest = isWebUsb && (requestQueue?.getRequestTasksId().length ?? 0) > 0;
+    // Bring up WebUSB even when schema configuration is deferred while a
+    // business request owns the discovery lock. Failures here used to be
+    // swallowed by configure(); keep searchDevices resolving empty.
+    if (isWebUsb) {
+      try {
+        await TransportManager.ensureInitialized();
+      } catch (error) {
+        Log.debug('WebUSB bring-up unavailable', error);
+      }
+    }
+    if (!hasActiveWebUsbRequest) await TransportManager.configure();
     const deviceDiff = await this.connector?.enumerate();
     const devicesDescriptor = deviceDiff?.descriptors ?? [];
 
-    const env = DataManager.getSettings('env');
-
     /**
      * No need to call features during Bluetooth scaning
      * to avoid device pairing
      */
     if (DataManager.isBleConnect(env)) {
-      const devices = [];
+      const devices: SearchDevice[] = [];
       const seenIds = new Set<string>();
 
       for (const device of devicesDescriptor) {
@@ -56,30 +138,42 @@ export default class SearchDevices extends BaseMethod {
       return devices;
     }
 
-    const deviceList = [];
+    const deviceList: SearchDevice[] = [];
     for (const descriptor of devicesDescriptor) {
-      try {
-        // Discovery is best effort. Browsers may retain WebUSB grants for devices that
-        // are offline, busy, or not ready, so one descriptor must not abort the scan.
-        const result = await DevicePool.getDevices([descriptor], descriptor.path, {
-          // Discovery must actively identify the protocol instead of trusting a caller hint.
-          connectProtocol: undefined,
-          forceProtocolDetection: true,
-          refreshRuntimeState: true,
-        });
-        deviceList.push(...result.deviceList);
-      } catch (error) {
-        const errorCode =
-          error && typeof error === 'object' && 'errorCode' in error
-            ? (error as { errorCode?: unknown }).errorCode
-            : undefined;
-        Log.debug('Skip unavailable device during search', {
-          path: descriptor.path,
-          ...(errorCode !== undefined ? { errorCode } : {}),
-        });
+      if (hasActiveWebUsbRequest && isOwnedByActiveWebUsbRequest(descriptor, requestQueue)) {
+        const cached = DevicePool.getDeviceByPath(descriptor.path);
+        const known = cached?.features ? cached : getOwningRequestDevice(descriptor, requestQueue);
+        const message = known ? toSearchDevice(known) : null;
+        // Do not probe a path an in-flight request already owns. A cache miss is still a
+        // connected device: report the owning request's device, or the path with no identity.
+        deviceList.push(message ?? toSearchDeviceFromDescriptor(descriptor));
+      } else {
+        try {
+          // Discovery is best effort. Browsers may retain WebUSB grants for devices that
+          // are offline, busy, or not ready, so one descriptor must not abort the scan.
+          const result = await DevicePool.getDevices([descriptor], descriptor.path, {
+            // Discovery must actively identify the protocol instead of trusting a caller hint.
+            connectProtocol: undefined,
+            forceProtocolDetection: true,
+            refreshRuntimeState: true,
+          });
+          for (const device of result.deviceList) {
+            const message = toSearchDevice(device);
+            if (message) deviceList.push(message);
+          }
+        } catch (error) {
+          const errorCode =
+            error && typeof error === 'object' && 'errorCode' in error
+              ? (error as { errorCode?: unknown }).errorCode
+              : undefined;
+          Log.debug('Skip unavailable device during search', {
+            path: descriptor.path,
+            ...(errorCode !== undefined ? { errorCode } : {}),
+          });
+        }
       }
     }
 
-    return deviceList.map(device => device.toMessageObject());
+    return deviceList;
   }
 }

package/src/api/UploadPortfolio.ts

@@ -7,6 +7,8 @@ import FileWrite from './FileWrite';
 export type UploadPortfolioParams = {
   packageBase64: string;
   timeoutMs?: number | string;
+  /** Controls transfer progress UI events. Defaults to `silent`. */
+  uiMode?: 'silent' | 'progress';
 };
 
 const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
@@ -17,7 +19,7 @@ const PORTFOLIO_UPDATE_MESSAGE_TYPE = 61400;
 
 export default class UploadPortfolio extends FileWrite {
   init() {
-    const { packageBase64, timeoutMs } = this.payload as UploadPortfolioParams;
+    const { packageBase64, timeoutMs, uiMode = 'silent' } = this.payload as UploadPortfolioParams;
     const packageBytes = decodeCanonicalBase64({
       value: packageBase64,
       parameterName: 'packageBase64',
@@ -31,13 +33,12 @@ export default class UploadPortfolio extends FileWrite {
       chunkSize: PORTFOLIO_CHUNK_SIZE,
       overwrite: true,
       append: false,
-      emitProgress: false,
+      emitProgress: uiMode === 'progress',
       timeoutMs,
     };
     super.init();
     this.unlockPolicy = 'none';
-    // Portfolio is a background write/apply flow and never synthesizes UI events.
-    this.protocolV2UiMode = 'none';
+    this.protocolV2UiMode = uiMode === 'progress' ? 'auto' : 'none';
   }
 
   async run() {

package/src/api/allnetwork/AllNetworkGetAddress.ts

@@ -7,21 +7,74 @@ import AllNetworkGetAddressBase from './AllNetworkGetAddressBase';
 import type { CoreApi } from '../../types';
 import type {
   AllNetworkAddress,
-  AllNetworkAddressParams,
   AllNetworkGetAddressParams,
 } from '../../types/api/allNetworkGetAddress';
 
-type MethodParams = {
-  methodName: keyof CoreApi;
-  params: Parameters<CoreApi[keyof CoreApi]>[0];
-  _originRequestParams: AllNetworkAddressParams;
-  _originalIndex: number;
-};
+type MethodParams = ReturnType<AllNetworkGetAddressBase['generateMethodName']>;
 
 export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
+  private checkAborted() {
+    if (this.abortController?.signal.aborted) {
+      throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
+    }
+  }
+
+  private async callAddressGroup(
+    methodName: keyof CoreApi,
+    params: MethodParams[],
+    rootFingerprint: number
+  ): Promise<AllNetworkAddress[]> {
+    const methodCallParams = { bundle: params.map(param => ({ ...param.params })) };
+    if (!this.device.isProtocolV2() || params.length === 1) {
+      return this.callMethod(methodName, methodCallParams, rootFingerprint);
+    }
+
+    const postedAddressCounts = new Map<string, number>();
+    let runningIndividually = false;
+    const postMessage: typeof this.postMessage = message => {
+      if (message.type === UI_REQUEST.PREVIOUS_ADDRESS_RESULT) {
+        const { path, address } = message.payload.data;
+        const key = JSON.stringify([path, address]);
+        const count = postedAddressCounts.get(key) ?? 0;
+        if (runningIndividually && count > 0) {
+          postedAddressCounts.set(key, count - 1);
+          return;
+        }
+        if (!runningIndividually) postedAddressCounts.set(key, count + 1);
+      }
+      this.postMessage(message);
+    };
+
+    // Only silent reads may be replayed. Forward their notifications immediately,
+    // then suppress matching retry copies by count so repeated inputs still emit.
+    if (params.every(param => param._originRequestParams.showOnOneKey === false)) {
+      const response = await this.callMethod(
+        methodName,
+        methodCallParams,
+        rootFingerprint,
+        postMessage
+      );
+      // Skippable errors become failed items; link, cancellation and wallet errors throw.
+      if (response.some(item => item.success)) return response;
+    }
+
+    runningIndividually = true;
+    const responses: AllNetworkAddress[] = [];
+    for (const param of params) {
+      this.checkAborted();
+      const response = await this.callMethod(
+        methodName,
+        { bundle: [{ ...param.params }] },
+        rootFingerprint,
+        postMessage
+      );
+      responses.push(...response);
+    }
+    return responses;
+  }
+
   async getAllNetworkAddress(rootFingerprint: number) {
     const responses: AllNetworkAddress[] = [];
-    const resultMap: Record<string, AllNetworkAddress> = {};
     const { bundle } = this.payload as AllNetworkGetAddressParams;
 
     const methodParams = bundle.map((param, index) =>
@@ -31,58 +84,39 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
         originalIndex: index,
       })
     );
-    const groupedMethodParams = methodParams.reduce((groups, param) => {
+    // Protocol V2 DeviceSessionGet is the Initialize(session_id) equivalent: the
+    // SE wallet stays selected until the next Ask/Get or lock. Nested chain
+    // methods still resume once in callMethod; same-method addresses can share
+    // that session the way Protocol V1 bundles do.
+    const methodGroups = methodParams.reduce((groups, param) => {
       const group = groups.get(param.methodName) ?? [];
       group.push(param);
       groups.set(param.methodName, group);
       return groups;
     }, new Map<keyof CoreApi, MethodParams[]>());
-    const requiresProtocolV2WalletHandoff =
-      this.device.isProtocolV2() &&
-      (this.payload.useEmptyPassphrase === true || !!this.payload.passphraseState);
-    const methodGroups: [keyof CoreApi, MethodParams[]][] = requiresProtocolV2WalletHandoff
-      ? methodParams.map(param => [param.methodName, [param]])
-      : Array.from(groupedMethodParams.entries());
 
-    let i = 0;
-    for (const [methodName, params] of methodGroups) {
-      const methodParams = {
-        bundle: params.map(param => ({
-          ...param.params,
-        })),
-      };
-
-      if (this.abortController?.signal.aborted) {
-        throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
-      }
-      // call method
-      const response = await this.callMethod(methodName, methodParams, rootFingerprint);
+    let processed = 0;
+    for (const [methodName, params] of methodGroups.entries()) {
+      this.checkAborted();
+      const response = await this.callAddressGroup(methodName, params, rootFingerprint);
+      this.checkAborted();
 
-      if (this.abortController?.signal.aborted) {
-        throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
-      }
-
-      for (let i = 0; i < params.length; i++) {
-        const { _originRequestParams, _originalIndex } = params[i];
-        const responseKey = `${_originalIndex}`;
-        resultMap[responseKey] = {
+      for (let index = 0; index < params.length; index++) {
+        const { _originRequestParams, _originalIndex } = params[index];
+        responses[_originalIndex] = {
           ..._originRequestParams,
-          ...response[i],
+          ...response[index],
         };
       }
 
-      if (this.payload?.bundle?.length > 1) {
-        const progress = Math.round(((i + 1) / this.payload.bundle.length) * 100);
+      processed += params.length;
+      if (bundle.length > 1) {
+        const progress = Math.round((processed / bundle.length) * 100);
         this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, { progress }));
       }
-      i++;
-    }
-
-    for (let i = 0; i < bundle.length; i++) {
-      responses.push(resultMap[i]);
     }
 
     this.abortController = null;
-    return Promise.resolve(responses);
+    return responses;
   }
 }