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

package/src/api/FirmwareUpdateV4.ts

@@ -352,13 +352,10 @@ const PROTOCOL_V2_TARGET_STATUS_BY_DECODED_NAME = new Map<string, number>([
   ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS', 10],
 ]);
 
-const isProtocolV2ReconnectProbeError = (error: unknown) => {
-  const message = getProtocolV2UnknownErrorText(error).toLowerCase();
-  return (
-    (message.includes('device protocol mismatch') && message.includes('expected v2')) ||
-    message.includes('did not respond to expected protocol')
-  );
-};
+const isProtocolV2ReconnectProbeError = (error: unknown) =>
+  getProtocolV2ErrorCode(error) === HardwareErrorCode.TransportProtocolProbeFailed &&
+  (error as { params?: { expectedProtocol?: unknown } } | undefined)?.params?.expectedProtocol ===
+    'V2';
 
 const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();

package/src/api/SearchDevices.ts

@@ -5,10 +5,20 @@ import TransportManager from '../data-manager/TransportManager';
 import { DataManager } from '../data-manager';
 import { LoggerNames, getDeviceTypeByBleName, getLogger } from '../utils';
 import { DevicePool } from '../device/DevicePool';
+import { buildProtocolV1FeaturesPayload } from '../deviceProfile/buildDeviceFeatures';
+import { mapProtocolV2DeviceInfoToState } from '../device/DeviceStateMapper';
+import { getSupportProtocolV1MessageSchema } from '../utils/deviceFeaturesUtils';
+import { PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST } from '../protocols/protocol-v2/features';
 
-import type { SearchDevice } from '../types/device';
+import type { SearchDevice, UsbDeviceIdentity } from '../types/device';
+import type { PROTO } from '../constants';
 import type DeviceConnector from '../device/DeviceConnector';
-import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import type {
+  AcquireInput,
+  OneKeyDeviceInfo as DeviceDescriptor,
+  ProtocolV2DeviceInfo,
+  Transport,
+} from '@onekeyfe/hd-transport';
 import type { Device } from '../device/Device';
 
 const Log = getLogger(LoggerNames.DevicePool);
@@ -18,7 +28,10 @@ type RequestQueueLookup = {
   getTask: (requestId: number) => { method: { device?: Device } } | undefined;
 };
 
-const getDescriptorKeys = (descriptor: DeviceDescriptor) =>
+export type UsbIdentityProbeDescriptor = Pick<DeviceDescriptor, 'path' | 'commType'> &
+  Partial<Pick<DeviceDescriptor, 'id' | 'session'>>;
+
+const getDescriptorKeys = (descriptor: UsbIdentityProbeDescriptor) =>
   [descriptor.path, descriptor.id].filter(
     (key): key is string => typeof key === 'string' && key.length > 0
   );
@@ -33,11 +46,11 @@ const isOwnedByActiveWebUsbRequest = (
   );
 };
 
-const getUsbHandle = (descriptor?: DeviceDescriptor) =>
+const getUsbHandle = (descriptor?: UsbIdentityProbeDescriptor) =>
   (descriptor as { device?: unknown } | undefined)?.device;
 
 const getOwningRequestDevice = (
-  descriptor: DeviceDescriptor,
+  descriptor: UsbIdentityProbeDescriptor,
   requestQueue?: RequestQueueLookup
 ) => {
   if (!requestQueue) return undefined;
@@ -60,6 +73,158 @@ const getOwningRequestDevice = (
   return undefined;
 };
 
+export const getOwnedUsbDeviceIdentity = (
+  descriptor: UsbIdentityProbeDescriptor,
+  requestQueue: RequestQueueLookup
+): UsbDeviceIdentity | undefined => {
+  const owner = getOwningRequestDevice(descriptor, requestQueue);
+  if (!owner || descriptor.commType !== 'webusb' || owner.originalDescriptor?.commType !== 'webusb')
+    return undefined;
+  return {
+    path: descriptor.path,
+    serialNo: owner.getCurrentSerialNo() || null,
+    deviceId: owner.getCurrentDeviceId() || null,
+    deviceType: owner.getCurrentDeviceType(),
+    connectProtocol: owner.getProtocol(),
+    commType: 'webusb',
+    mode: owner.features?.mode ?? undefined,
+  };
+};
+
+export type UsbIdentityProbeTransport = Pick<
+  Transport,
+  'release' | 'call' | 'getProtocolType' | 'configureProtocolV2'
+> & {
+  init: (logger: object) => unknown;
+  enumerate: () => Promise<UsbIdentityProbeDescriptor[]>;
+  acquire: (input: AcquireInput) => Promise<string | undefined>;
+  configure: (signedData: string) => void | Promise<void>;
+};
+
+// Identity discovery must not publish device events or log raw Features/session data.
+const identityProbeLogger = {
+  debug: () => undefined,
+  log: () => undefined,
+  info: () => undefined,
+  warn: () => undefined,
+  error: () => undefined,
+};
+
+/** Runs on a separate transport; never initializes or switches the current Core. */
+export const probeUsbDeviceIdentitiesWithTransport = async (
+  transport: UsbIdentityProbeTransport,
+  commType: UsbDeviceIdentity['commType'],
+  getOwnedIdentity?: (descriptor: UsbIdentityProbeDescriptor) => UsbDeviceIdentity | undefined
+): Promise<UsbDeviceIdentity[]> => {
+  if (commType !== 'webusb') return [];
+  await transport.init(identityProbeLogger);
+  const defaultMessages = JSON.stringify(DataManager.getProtobufMessages());
+  await transport.configure(defaultMessages);
+  await transport.configureProtocolV2?.(
+    JSON.stringify(DataManager.getProtobufMessages('v2Schema'))
+  );
+  const descriptors = await transport.enumerate();
+  const identities: UsbDeviceIdentity[] = [];
+  const readIdentity = async (
+    descriptor: UsbIdentityProbeDescriptor
+  ): Promise<UsbDeviceIdentity | undefined> => {
+    const { path } = descriptor;
+    if (!path || descriptor.commType !== commType) return undefined;
+    if (descriptors.filter(candidate => candidate.path === path).length !== 1) return undefined;
+    const owner = getOwnedIdentity?.(descriptor);
+    if (owner) {
+      return owner;
+    }
+    // Do not borrow a browser handle or replace a Bridge session owned by another call.
+    if (descriptor.session || (getUsbHandle(descriptor) as USBDevice | undefined)?.opened)
+      return undefined;
+
+    let session: string | undefined;
+    let identified: UsbDeviceIdentity | undefined;
+    try {
+      await transport.configure(defaultMessages);
+      session = await transport.acquire({ path, previous: null, forceProtocolDetection: true });
+      if (!session) return undefined;
+      const protocol = transport.getProtocolType(path);
+      if (protocol === 'V1') {
+        const response = await transport.call(session, 'GetFeatures', {}, { timeoutMs: 3000 });
+        if (response.type !== 'Features') return undefined;
+        let features = buildProtocolV1FeaturesPayload(response.message as PROTO.Features);
+        // Classic-family loaders expose their supported information in Features.
+        // Touch/Pro retain their existing vendor-feature query.
+        if (
+          !features.serialNo &&
+          (features.mode !== 'bootloader' ||
+            features.deviceType === EDeviceType.Touch ||
+            features.deviceType === EDeviceType.Pro)
+        ) {
+          const { messages, protocolV1MessageSchema } = getSupportProtocolV1MessageSchema(features);
+          // Legacy V1 has no OnekeyGetFeatures; keep the identity confirmed by GetFeatures.
+          if (protocolV1MessageSchema === 'v1CurrentSchema') {
+            if (messages) await transport.configure(JSON.stringify(messages));
+            const vendor = await transport.call(
+              session,
+              'OnekeyGetFeatures',
+              {},
+              { timeoutMs: 3000 }
+            );
+            if (vendor.type === 'OnekeyFeatures') {
+              features = buildProtocolV1FeaturesPayload({
+                ...response.message,
+                ...vendor.message,
+              } as PROTO.Features);
+            }
+          }
+        }
+        identified = {
+          path,
+          serialNo: features.serialNo || null,
+          deviceId: features.deviceId || null,
+          deviceType: features.deviceType,
+          connectProtocol: 'V1',
+          commType,
+          mode: features.mode ?? undefined,
+        };
+      } else if (protocol === 'V2') {
+        const response = await transport.call(
+          session,
+          'DeviceInfoGet',
+          PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
+          { timeoutMs: 3000 }
+        );
+        if (response.type !== 'DeviceInfo') return undefined;
+        const { identity } = mapProtocolV2DeviceInfoToState(
+          response.message as ProtocolV2DeviceInfo
+        );
+        identified = {
+          path,
+          serialNo: identity?.serialNo || null,
+          deviceId: identity?.deviceId || null,
+          deviceType: identity?.deviceType ?? EDeviceType.Unknown,
+          connectProtocol: 'V2',
+          commType,
+        };
+      }
+    } catch {
+      // Discovery is best effort; a busy/disconnected device cannot confirm identity.
+    } finally {
+      if (session) {
+        try {
+          await transport.release(session, false);
+        } catch {
+          identified = undefined;
+        }
+      }
+    }
+    return identified;
+  };
+  for (const descriptor of descriptors) {
+    const identity = await readIdentity(descriptor);
+    if (identity) identities.push(identity);
+  }
+  return identities;
+};
+
 // 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 => {
@@ -81,7 +246,7 @@ const toSearchDevice = (device: Device): SearchDevice | null => {
 };
 
 export default class SearchDevices extends BaseMethod {
-  connector?: DeviceConnector;
+  connector?: DeviceConnector = undefined;
 
   init() {
     this.useDevice = false;
@@ -130,7 +295,7 @@ export default class SearchDevices extends BaseMethod {
             // BLE discovery cannot provide a physical-device identity before initialization.
             uuid: '',
             deviceId: null,
-            name: bleName || device.name,
+            name: bleName || device.name || '',
             deviceType: getDeviceTypeByBleName(bleName),
           });
         }

package/src/api/index.ts

@@ -175,5 +175,3 @@ export { default as benfenSignTransaction } from './benfen/BenfenSignTransaction
 
 export { default as neoGetAddress } from './neo/NeoGetAddress';
 export { default as neoSignTransaction } from './neo/NeoSignTransaction';
-export { default as zcashGetAddress } from './zcash/ZcashGetAddress';
-export { default as zcashSignPczt } from './zcash/ZcashSignPczt';

package/src/core/index.ts

@@ -1,4 +1,5 @@
 import semver from 'semver';
+import { getOwnedUsbDeviceIdentity } from '../api/SearchDevices';
 import EventEmitter from 'events';
 import {
   DeviceSessionPinType,
@@ -125,6 +126,8 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
 });
 
 let _core: Core | undefined;
+let transportSwitchGeneration = 0;
+let pendingTransportSwitch: Promise<void> = Promise.resolve();
 let _deviceList: DeviceList | undefined;
 let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
@@ -990,15 +993,11 @@ function canSkipInitialize(method: BaseMethod, device: Device): boolean {
 }
 
 export function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
-  const typedError = error as { errorCode?: unknown; message?: unknown };
-  const message =
-    typeof typedError?.message === 'string' ? typedError.message : String(error ?? '');
+  const typedError = error as { errorCode?: unknown; params?: { expectedProtocol?: unknown } };
   return (
     method.payload.connectProtocol === 'V2' &&
-    typedError?.errorCode === HardwareErrorCode.RuntimeError &&
-    message.includes('Device protocol mismatch') &&
-    message.includes('expected V2') &&
-    message.includes('did not respond to expected protocol')
+    typedError?.errorCode === HardwareErrorCode.TransportProtocolProbeFailed &&
+    typedError.params?.expectedProtocol === 'V2'
   );
 }
 
@@ -1008,7 +1007,7 @@ export function isRetryableBleConnectionError(method: BaseMethod, error: unknown
   }
   const typedError = error as {
     errorCode?: unknown;
-    params?: { acquireDeadlineExceeded?: unknown };
+    params?: { acquireDeadlineExceeded?: unknown; expectedProtocol?: unknown };
   };
   if (
     typedError?.errorCode === HardwareErrorCode.BleTimeoutError &&
@@ -1019,6 +1018,8 @@ export function isRetryableBleConnectionError(method: BaseMethod, error: unknown
   return (
     typedError?.errorCode === HardwareErrorCode.BleTimeoutError ||
     typedError?.errorCode === HardwareErrorCode.BleConnectedError ||
+    (typedError?.errorCode === HardwareErrorCode.TransportProtocolProbeFailed &&
+      !typedError.params?.expectedProtocol) ||
     isRetryableBleProtocolV2ProbeError(method, error) ||
     isMissingDetectedProtocolV2Error(method, error)
   );
@@ -1273,6 +1274,8 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeTimeoutError,
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
           ].includes(error.errorCode)
         ) {
           _deviceList = undefined;
@@ -1360,6 +1363,8 @@ const ensureConnected = async (
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
           ].includes(error.errorCode) ||
@@ -1826,6 +1831,10 @@ export default class Core extends EventEmitter {
 
   private requestQueue = new RequestQueue();
 
+  getOwnedUsbDeviceIdentity(descriptor: Parameters<typeof getOwnedUsbDeviceIdentity>[0]) {
+    return getOwnedUsbDeviceIdentity(descriptor, this.requestQueue);
+  }
+
   private disposePromise?: Promise<void>;
 
   // background task
@@ -1959,6 +1968,8 @@ export default class Core extends EventEmitter {
 
   private async disposeResources(): Promise<void> {
     Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    transportSwitchGeneration += 1;
+    pendingTransportSwitch = Promise.resolve();
     pollingManager.stopAll();
     this.requestQueue.abortAllRequests();
     cleanup();
@@ -1993,6 +2004,8 @@ export default class Core extends EventEmitter {
 }
 
 export const initCore = () => {
+  transportSwitchGeneration += 1;
+  pendingTransportSwitch = Promise.resolve();
   const core = new Core();
   _core = core;
   return core;
@@ -2022,6 +2035,8 @@ export const init = async (
   plugin?: LowlevelTransportSharedPlugin
 ) => {
   try {
+    transportSwitchGeneration += 1;
+    pendingTransportSwitch = Promise.resolve();
     await DataManager.load(settings);
     initTransport(Transport, plugin);
     enableLog(DataManager.getSettings('debug'));
@@ -2047,10 +2062,26 @@ export const switchTransport = ({
   Transport: any;
   plugin?: LowlevelTransportSharedPlugin;
 }) => {
-  DataManager.updateEnv(env);
-  TransportManager.setTransport(Transport, plugin);
-  _deviceList = undefined;
-  DevicePool.resetState();
-  _connector = undefined;
-  initConnector();
+  const generation = transportSwitchGeneration;
+  // Preserve request order while native transport cleanup is pending.
+  const switching = pendingTransportSwitch
+    .catch(() => undefined)
+    .then(async () => {
+      if (generation !== transportSwitchGeneration) {
+        throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
+      }
+      _connector?.stop();
+      await TransportManager.getTransport()?.stop?.();
+      if (generation !== transportSwitchGeneration) {
+        throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
+      }
+      DataManager.updateEnv(env);
+      TransportManager.setTransport(Transport, plugin);
+      _deviceList = undefined;
+      DevicePool.resetState();
+      _connector = undefined;
+      initConnector();
+    });
+  pendingTransportSwitch = switching;
+  return switching;
 };

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

@@ -11034,61 +11034,6 @@
         }
       }
     },
-    "ZcashSignPczt": {
-      "fields": {
-        "pczt_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        },
-        "pczt_initial_chunk": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 2
-        }
-      }
-    },
-    "ZcashPcztChunkRequest": {
-      "fields": {
-        "chunk_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        }
-      }
-    },
-    "ZcashPcztChunkAck": {
-      "fields": {
-        "data_chunk": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 1
-        }
-      }
-    },
-    "ZcashSignedPczt": {
-      "fields": {
-        "pczt_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        },
-        "pczt_initial_chunk": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 2
-        }
-      }
-    },
-    "ZcashSignedPcztChunkRequest": {
-      "fields": {
-        "chunk_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        }
-      }
-    },
     "wire_in": {
       "type": "bool",
       "id": 50002,
@@ -11514,11 +11459,6 @@
         "MessageType_NeoAddress": 12302,
         "MessageType_NeoSignTx": 12303,
         "MessageType_NeoSignedTx": 12304,
-        "MessageType_ZcashSignPczt": 12402,
-        "MessageType_ZcashSignedPczt": 12403,
-        "MessageType_ZcashPcztChunkRequest": 12404,
-        "MessageType_ZcashPcztChunkAck": 12405,
-        "MessageType_ZcashSignedPcztChunkRequest": 12406,
         "MessageType_DeviceFactoryInfoSet": 60000,
         "MessageType_DeviceFactoryInfoGet": 60001,
         "MessageType_DeviceFactoryInfo": 60002,
@@ -11571,9 +11511,7 @@
         "MessageType_PortfolioUpdate": 61400,
         "MessageType_NftUpdate": 61500,
         "MessageType_OnboardingStatusGet": 61600,
-        "MessageType_OnboardingStatus": 61601,
-        "MessageType_ZcashGetAddress": 12400,
-        "MessageType_ZcashAddress": 12401
+        "MessageType_OnboardingStatus": 61601
       },
       "reserved": [
         [90, 92],
@@ -13792,81 +13730,6 @@
           }
         }
       }
-    },
-    "ZcashAddressType": {
-      "values": {
-        "UNIFIED_ORCHARD_P2PKH": 0,
-        "TRANSPARENT_P2PKH": 1,
-        "UNIFIED_ORCHARD": 2
-      }
-    },
-    "ZcashAddressScope": {
-      "values": {
-        "EXTERNAL": 0,
-        "INTERNAL": 1
-      }
-    },
-    "ZcashGetAddress": {
-      "fields": {
-        "address_n": {
-          "rule": "repeated",
-          "type": "uint32",
-          "id": 1,
-          "options": {
-            "packed": false
-          }
-        },
-        "show_display": {
-          "type": "bool",
-          "id": 2
-        },
-        "include_seed_fingerprint": {
-          "type": "bool",
-          "id": 3
-        },
-        "include_ufvk": {
-          "type": "bool",
-          "id": 4
-        },
-        "diversifier_index": {
-          "type": "uint32",
-          "id": 5,
-          "options": {
-            "default": 0
-          }
-        },
-        "address_type": {
-          "type": "ZcashAddressType",
-          "id": 6,
-          "options": {
-            "default": "UNIFIED_ORCHARD_P2PKH"
-          }
-        },
-        "scope": {
-          "type": "ZcashAddressScope",
-          "id": 7,
-          "options": {
-            "default": "EXTERNAL"
-          }
-        }
-      }
-    },
-    "ZcashAddress": {
-      "fields": {
-        "address": {
-          "rule": "required",
-          "type": "string",
-          "id": 1
-        },
-        "ufvk": {
-          "type": "string",
-          "id": 2
-        },
-        "seed_fingerprint": {
-          "type": "bytes",
-          "id": 3
-        }
-      }
     }
   }
 }

package/src/device/DeviceConnector.ts

@@ -133,10 +133,10 @@ export default class DeviceConnector {
             : undefined;
         const detectedProtocol = acquiredProtocol ?? transport.getProtocolType(path);
         if (detectedProtocol !== expectedProtocol) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.RuntimeError,
-            `Device protocol mismatch: expected ${expectedProtocol}, detected ${detectedProtocol}`
-          );
+          throw ERRORS.TypedError(HardwareErrorCode.TransportProtocolMismatch, undefined, {
+            expectedProtocol,
+            detectedProtocol,
+          });
         }
       }
       return res;

package/src/events/logBlockEvent.ts

@@ -8,8 +8,8 @@ export const LogBlockEvent: Set<string> = new Set([
   UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
 
-// Drop sensitive wallet payloads and large resource data before logger caches
-// or log events can retain them, regardless of whether debug output is enabled.
+// These resource/file APIs did not exist in 1.1.32. Skip the payload so
+// the log layer does not copy huge Base64 or binary data.
 const LogPayloadBlockMethod: Set<string> = new Set([
   'btcDeriveContextHash',
   'deviceUploadNft',
@@ -17,9 +17,6 @@ const LogPayloadBlockMethod: Set<string> = new Set([
   'uploadPortfolio',
   'fileWrite',
   'fileRead',
-  'zcashGetAddress',
-  'zcashGetUnifiedAddress',
-  'zcashSignPczt',
 ]);
 
 export function getLogBlockLabel(message: unknown): string | undefined {

package/src/index.ts

@@ -21,6 +21,7 @@ export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
 export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
 export { getMethodSupportedProtocols } from './api/utils';
+export { probeUsbDeviceIdentitiesWithTransport } from './api/SearchDevices';
 export {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,

package/src/inject.ts

@@ -504,8 +504,4 @@ export const createCoreApi = (
     call({ ...params, connectId, deviceId, method: 'neoGetAddress' }),
   neoSignTransaction: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'neoSignTransaction' }),
-  zcashGetAddress: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'zcashGetAddress' }),
-  zcashSignPczt: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'zcashSignPczt' }),
 });

package/src/types/api/export.ts

@@ -227,5 +227,3 @@ export type { BenfenAddress, BenfenGetAddressParams } from './benfenGetAddress';
 export type { BenfenPublicKey, BenfenGetPublicKeyParams } from './benfenGetPublicKey';
 export type { BenfenSignMessageParams } from './benfenSignMessage';
 export type { BenfenSignedTx, BenfenSignTransactionParams } from './benfenSignTransaction';
-export type { ZcashAddress, ZcashGetAddressParams } from './zcashGetAddress';
-export type { ZcashSignedPczt, ZcashSignPcztParams } from './zcashSignPczt';

package/src/types/api/index.ts

@@ -154,8 +154,6 @@ import type { benfenSignTransaction } from './benfenSignTransaction';
 import type { benfenSignMessage } from './benfenSignMessage';
 import type { neoGetAddress } from './neoGetAddress';
 import type { neoSignTransaction } from './neoSignTransaction';
-import type { zcashGetAddress } from './zcashGetAddress';
-import type { zcashSignPczt } from './zcashSignPczt';
 import type { ConnectSettings } from '../settings';
 import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 
@@ -474,10 +472,4 @@ export type CoreApi = {
    */
   neoGetAddress: typeof neoGetAddress;
   neoSignTransaction: typeof neoSignTransaction;
-
-  /**
-   * Zcash
-   */
-  zcashGetAddress: typeof zcashGetAddress;
-  zcashSignPczt: typeof zcashSignPczt;
 };

package/src/types/device.ts

@@ -85,6 +85,18 @@ export type SearchDevice = {
   commType: OneKeyDeviceCommType;
 };
 
+/** Identity confirmed over USB. The descriptor path is only a transport address. */
+export type UsbDeviceIdentity = {
+  path: string;
+  serialNo: string | null;
+  deviceId: string | null;
+  deviceType: IDeviceType;
+  connectProtocol: HardwareConnectProtocol;
+  commType: 'webusb' | 'bridge';
+  /** Mode confirmed by the device response; absent when discovery cannot establish it. */
+  mode?: DeviceStateMode;
+};
+
 // export type UnknownDevice = {
 //   type: 'unacquired';
 //   id?: null;