@onekeyfe/hd-core 1.2.8-alpha.9 → 1.2.10-alpha.1

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/allnetwork/AllNetworkGetAddressBase.ts

@@ -9,7 +9,7 @@ import {
 
 import { serializedPath, toHardened } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
-import { validateParams } from '../helpers/paramsValidator';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
 import { PROTO } from '../../constants';
 import { findMethod } from '../utils';
 import { DEVICE, IFRAME, createUiMessage } from '../../events';
@@ -35,6 +35,12 @@ import type {
 
 const Mainnet = 'mainnet';
 
+const MoneroNetworkTypes = new Map<string, number>([
+  [Mainnet, PROTO.MoneroNetworkType.MAINNET],
+  ['testnet', PROTO.MoneroNetworkType.TESTNET],
+  ['stagenet', PROTO.MoneroNetworkType.STAGENET],
+]);
+
 export type NetworkConfig = {
   methodName: keyof CoreApi;
   getParams?: (baseParams: AllNetworkAddressParams, chainName?: string, methodName?: string) => any;
@@ -246,6 +252,37 @@ const networkConfigMap: NetworkConfigMap = {
   stellar: {
     methodName: 'stellarGetAddress',
   },
+  xmr: {
+    methodName: 'moneroGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams, chainName?: string) => {
+      const { path, showOnOneKey } = baseParams;
+      const networkType = MoneroNetworkTypes.get(chainName ?? Mainnet);
+      if (networkType === undefined) {
+        throw invalidParameter(`Unsupported Monero chainName: ${chainName}`);
+      }
+      return {
+        path,
+        networkType,
+        showOnOneKey,
+      };
+    },
+  },
+  zcash: {
+    methodName: 'zcashGetAddress',
+    // The account's unified address with the keys a wallet needs to watch it.
+    getParams: (baseParams: AllNetworkAddressParams) => {
+      const { path, showOnOneKey } = baseParams;
+      return {
+        path,
+        showOnOneKey,
+        addressType: PROTO.ZcashAddressType.UNIFIED_ORCHARD,
+        scope: PROTO.ZcashAddressScope.EXTERNAL,
+        diversifierIndex: 0,
+        includeUfvk: true,
+        includeSeedFingerprint: true,
+      };
+    },
+  },
 };
 
 type MethodParams = {

package/src/api/btc/BTCDeriveContextHash.ts

@@ -0,0 +1,90 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Buffer } from 'buffer';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { getScriptType, validatePath } from '../helpers/pathUtils';
+
+import type { BabylonDeriveContextHash, CanonicalBitcoinNetwork } from '@onekeyfe/hd-transport';
+import type { BTCDeriveContextHashParams } from '../../types';
+
+const NETWORKS: Record<BTCDeriveContextHashParams['network'], CanonicalBitcoinNetwork> = {
+  'bitcoin-mainnet': 'BITCOIN_MAINNET',
+  'bitcoin-testnet': 'BITCOIN_TESTNET',
+  'bitcoin-signet': 'BITCOIN_SIGNET',
+  'bitcoin-regtest': 'BITCOIN_REGTEST',
+};
+
+export default class BTCDeriveContextHash extends BaseMethod<BabylonDeriveContextHash> {
+  strictCheckDeviceSupport = true;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowUsePreInitialize = true;
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'appName', type: 'string', required: true },
+      { name: 'context', type: 'string', required: true },
+      { name: 'network', type: 'string', required: true },
+    ]);
+
+    const { path, appName, context, network } = this.payload;
+    if (typeof appName !== 'string' || !/^[a-z0-9-]{1,64}$/.test(appName)) {
+      throw invalidParameter(
+        'appName must contain 1..64 ASCII lowercase letters, digits or hyphens'
+      );
+    }
+    if (typeof context !== 'string' || !/^(?:[0-9a-f]{2}){1,1024}$/.test(context)) {
+      throw invalidParameter('context must be 1..1024 bytes of lowercase hex without a prefix');
+    }
+    if (typeof network !== 'string' || !Object.prototype.hasOwnProperty.call(NETWORKS, network)) {
+      throw invalidParameter('Unsupported Bitcoin network');
+    }
+
+    // Reject malformed or overflowing indices before validatePath can truncate them.
+    if (
+      (typeof path === 'string' &&
+        (!/^m(?:\/\d+'?)+$/i.test(path) ||
+          path
+            .split('/')
+            .slice(1)
+            .some(index => Number(index.replace(/'/g, '')) >= 0x80000000))) ||
+      (Array.isArray(path) &&
+        path.findIndex(index => !Number.isInteger(index) || index < 0 || index > 0xffffffff) !== -1)
+    ) {
+      throw invalidParameter('Not a valid BIP-32 path');
+    }
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      script_type: getScriptType(addressN),
+      app_name: Buffer.from(appName, 'ascii').toString('hex'),
+      context,
+      network: NETWORKS[network as BTCDeriveContextHashParams['network']],
+    };
+  }
+
+  getVersionRange() {
+    return {
+      classic1s: { min: '3.21.0' },
+      classicpure: { min: '3.21.0' },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'BabylonDeriveContextHash',
+      'BabylonDerivedContextHash',
+      this.params
+    );
+    if (typeof message.secret !== 'string' || !/^[0-9a-f]{64}$/.test(message.secret)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodError,
+        'Invalid Babylon context hash response'
+      );
+    }
+    return message;
+  }
+}

package/src/api/firmware/FirmwareArtifactSource.ts

@@ -212,17 +212,26 @@ export const readVerifiedFirmwareArtifact = async ({
 }): Promise<ArrayBuffer> => {
   assertFirmwareArtifactReference(artifact);
   const source = await ReaderFirmwareByteSource.open(artifact, reader);
+  const hasher = sha256.create();
   try {
-    const binary = await readFirmwareByteSourceFully(source);
-    const actualSha256 = bytesToHex(sha256(new Uint8Array(binary)));
+    const bytes = new Uint8Array(source.size);
+    let offset = 0;
+    while (offset < source.size) {
+      const length = Math.min(MAX_FIRMWARE_ARTIFACT_READ_BYTES, source.size - offset);
+      bytes.set(new Uint8Array(await source.readAt(offset, length)), offset);
+      hasher.update(bytes.subarray(offset, offset + length));
+      offset += length;
+    }
+    const actualSha256 = bytesToHex(hasher.digest());
     if (actualSha256 !== artifact.sha256.toLowerCase()) {
       return artifactError(
         'FirmwareArtifactReceiptMismatch',
         'Firmware artifact bytes do not match the approved SHA-256 receipt'
       );
     }
-    return binary;
+    return bytes.buffer;
   } finally {
+    hasher.destroy();
     await source.close().catch(() => undefined);
   }
 };

package/src/api/helpers/pathUtils.ts

@@ -143,3 +143,26 @@ export const validatePath = (
   if (length > 0 && valid.length < length) throw PATH_NOT_VALID;
   return base ? valid.splice(0, 3) : valid;
 };
+
+const isTextIndex = (part: string) => {
+  const digits = /^(\d+)'?$/.exec(part)?.[1];
+  return digits !== undefined && Number(digits) < HD_HARDENED;
+};
+
+const isUint32 = (n: number) => Number.isInteger(n) && n >= 0 && n <= 0xffffffff;
+
+// validatePath lets parseInt and 32-bit hardening alias fractional or oversized
+// components to another index: 0.5' and 4294967296' both become 0'.
+export const validateStrictPath = (path: string | Array<number>, length = 0): Array<number> => {
+  const addressN = validatePath(path, length);
+  const isStrict =
+    typeof path === 'string'
+      ? path
+          .toLowerCase()
+          .split('/')
+          .filter(p => p !== 'm' && p !== '')
+          .every(isTextIndex)
+      : path.every(isUint32);
+  if (!isStrict) throw PATH_NOT_VALID;
+  return addressN;
+};