@onekeyfe/hd-core 1.2.8-alpha.13 → 1.2.8-alpha.131

package/src/device/Device.ts

@@ -236,6 +236,9 @@ export class Device extends EventEmitter {
    */
   private deviceAcquired = false;
 
+  /** A completed BLE release left the physical link available for the next call. */
+  private releasedBleConnection = false;
+
   /**
    * Connection-attempt generation. interruptionFromUser() pins the current
    * attempt so a late acquire cannot finish, while the next public connect
@@ -452,6 +455,7 @@ export class Device extends EventEmitter {
   ) {
     const attempt = this.connectionAttempt;
     this.throwIfInterruptedByUser();
+    this.releasedBleConnection = false;
     const env = DataManager.getSettings('env');
     const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
     const previousProtocol = this.originalDescriptor.protocolType;
@@ -562,6 +566,7 @@ export class Device extends EventEmitter {
       (this.isUsedHere() && !this.keepSession && this.mainId) ||
       (this.mainId && DataManager.isBleConnect(env))
     ) {
+      this.releasedBleConnection = false;
       // wait for callback tasks to complete before releasing device
       if (this.pendingCallbackPromise) {
         try {
@@ -585,12 +590,24 @@ export class Device extends EventEmitter {
         }
       }
       try {
+        const deviceType = this.getCurrentDeviceType();
+        const keepBleConnection =
+          (env === 'react-native' || env === 'desktop-web-ble') &&
+          this.isProtocolV2() &&
+          (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo);
         // BLE releases even when keepSession is set, so forward the intent.
-        await this.deviceConnector?.release(this.mainId, false, this.keepSession);
-        this.updateDescriptor({ session: null } as DeviceDescriptor);
+        await this.deviceConnector?.release(
+          this.mainId,
+          false,
+          this.keepSession || keepBleConnection
+        );
+        this.releasedBleConnection = keepBleConnection;
       } catch (err) {
         Log.error('[Device] release error: ', err);
       } finally {
+        // Core no longer owns a logical transport session after release starts,
+        // even if native cleanup must be retried by the transport.
+        this.updateDescriptor({ session: null } as DeviceDescriptor);
         this.needReloadDevice = true;
       }
     }
@@ -1369,6 +1386,7 @@ export class Device extends EventEmitter {
 
   markTransportDisconnected() {
     this.deviceAcquired = false;
+    this.releasedBleConnection = false;
     this.invalidateProtocolV2RuntimeState();
   }
 
@@ -1631,7 +1649,7 @@ export class Device extends EventEmitter {
           await commands?.cancelDevice?.().catch(cancelError => {
             Log.debug('Protocol V2 fallback cancel error', cancelError);
           });
-        } else if (!acquired) {
+        } else if (!acquired && !this.releasedBleConnection) {
           // Abort setup without acquiring a session just to send Cancel.
           if (mainId && deviceConnector?.disconnect) {
             // The connector drops the link silently, so without this line a

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,
 ]);
 
-// 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.
+// Drop sensitive wallet payloads and large resource data before logger caches
+// or log events can retain them, regardless of whether debug output is enabled.
 const LogPayloadBlockMethod: Set<string> = new Set([
   'btcDeriveContextHash',
   'deviceUploadNft',
@@ -17,6 +17,12 @@ const LogPayloadBlockMethod: Set<string> = new Set([
   'uploadPortfolio',
   'fileWrite',
   'fileRead',
+  'zcashGetAddress',
+  'zcashSignPczt',
+  'moneroGetAddress',
+  'moneroGetWatchKey',
+  'moneroKeyImageSync',
+  'moneroSignTransaction',
 ]);
 
 export function getLogBlockLabel(message: unknown): string | undefined {
@@ -40,11 +46,57 @@ export function getLogBlockLabel(message: unknown): string | undefined {
   return undefined;
 }
 
+// All-network results of these networks carry what their own address methods
+// keep out of logs (viewing keys, private addresses).
+const LogPayloadBlockNetwork: Set<string> = new Set(['zcash', 'xmr']);
+
+type AllNetworkLogItem = { network?: string; success?: boolean; payload?: object | string } | null;
+
+// A call response lists the results in `payload`; a loop callback carries one
+// result, or all of them when finished, in `payload.data`.
+type AllNetworkLogMessage = {
+  payload?: AllNetworkLogItem[] | { data?: AllNetworkLogItem | AllNetworkLogItem[] };
+};
+
+function redactAllNetworkItem(item: AllNetworkLogItem): AllNetworkLogItem {
+  if (!item || item.success === false || item.payload === undefined) return item;
+  return item.network && LogPayloadBlockNetwork.has(item.network)
+    ? { ...item, payload: '[REDACTED]' }
+    : item;
+}
+
+function redactAllNetworkItems(items: AllNetworkLogItem[]) {
+  const redacted = items.map(redactAllNetworkItem);
+  return redacted.some((item, index) => item !== items[index]) ? redacted : items;
+}
+
+// Returns `message` itself when nothing needs redacting.
+function redactAllNetworkResults(message: AllNetworkLogMessage): AllNetworkLogMessage {
+  const { payload } = message;
+  if (Array.isArray(payload)) {
+    const items = redactAllNetworkItems(payload);
+    return items === payload ? message : { ...message, payload: items };
+  }
+  const data = payload?.data;
+  if (!data) return message;
+  const redacted = Array.isArray(data) ? redactAllNetworkItems(data) : redactAllNetworkItem(data);
+  return redacted === data ? message : { ...message, payload: { ...payload, data: redacted } };
+}
+
 export function getSafeLogPayload(value: unknown, blockLabel?: string): unknown {
   if (blockLabel) {
     return { method: blockLabel, payload: '[REDACTED]' };
   }
-  return value;
+  if (!value || typeof value !== 'object') return value;
+  return redactAllNetworkResults(value as AllNetworkLogMessage);
+}
+
+// A queued task holds its method's raw payload; redact it like the call.
+export function getSafeLogTask<T extends { id?: number; method?: { payload?: unknown } }>(
+  task: T | undefined
+): T | { id?: number; method: string; payload: string } | undefined {
+  const blockLabel = getLogBlockLabel(task?.method?.payload);
+  return blockLabel ? { id: task?.id, method: blockLabel, payload: '[REDACTED]' } : task;
 }
 
 export function formatLogMethodLabel(label: string, methodName?: string): string {

package/src/events/ui-request.ts

@@ -211,6 +211,7 @@ export interface DeviceProgress {
     totalBytes?: number;
     rateBytesPerSecond?: number;
     elapsedMs?: number;
+    retryCount?: number;
   };
 }
 
@@ -218,6 +219,7 @@ export interface PreviousAddressResult {
   type: typeof UI_REQUEST.PREVIOUS_ADDRESS_RESULT;
   payload: {
     device: Device;
+    method: string;
     data: {
       address?: string;
       path?: string;

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,4 +504,17 @@ 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' }),
+
+  moneroGetAddress: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'moneroGetAddress' }),
+  moneroGetWatchKey: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'moneroGetWatchKey' }),
+  moneroKeyImageSync: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'moneroKeyImageSync' }),
+  moneroSignTransaction: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'moneroSignTransaction' }),
 });

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

@@ -7,6 +7,8 @@ export const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH =
 export const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
 export const PROTOCOL_V2_ROM_PARAMS_PACKAGE_PATH = 'vol0:/loaders/rom/params.okpkg';
 export const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE = 0x5f90;
+// Installed-package comparison only needs the prefix through the header hash.
+export const PROTOCOL_V2_RESOURCE_PACKAGE_COMPARE_SIZE = 0x280;
 
 const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_VERSION = 1;
 const PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_OFFSET = 0x6c;
@@ -123,7 +125,7 @@ export function parseProtocolV2ResourcePackageHeader(
   bytes: Uint8Array,
   packageSize: number
 ): ProtocolV2ResourcePackageHeader {
-  if (bytes.byteLength < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
+  if (bytes.byteLength < PROTOCOL_V2_RESOURCE_PACKAGE_COMPARE_SIZE) {
     throw new Error('Pro2 RESOURCE package is shorter than its header');
   }
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
@@ -169,5 +171,8 @@ export function parseProtocolV2ResourcePackage(
   binary: ArrayBuffer | Uint8Array
 ): ProtocolV2ResourcePackageHeader {
   const bytes = binary instanceof Uint8Array ? binary : new Uint8Array(binary);
+  if (bytes.byteLength < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
+    throw new Error('Pro2 RESOURCE package is shorter than its header');
+  }
   return parseProtocolV2ResourcePackageHeader(bytes, bytes.byteLength);
 }

package/src/types/api/allNetworkGetAddress.ts

@@ -34,7 +34,9 @@ export type INetwork =
   | 'nostr'
   | 'benfen'
   | 'neo'
-  | 'stellar';
+  | 'stellar'
+  | 'xmr'
+  | 'zcash';
 
 export type CommonResponseParams = {
   path: string;
@@ -66,6 +68,12 @@ type AllNetworkAddressPayload =
       // Nostr public key (bech32)
       npub?: string;
     }
+  | {
+      // Zcash
+      address: string;
+      ufvk?: string;
+      seedFingerprint?: string;
+    }
   | {
       // Cardano
       addressParameters: CardanoAddressParameters;

package/src/types/api/export.ts

@@ -227,3 +227,18 @@ 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';
+
+export type { MoneroAddress, MoneroGetAddressParams } from './moneroGetAddress';
+export type { MoneroGetWatchKeyParams, MoneroWatchKey } from './moneroGetWatchKey';
+export type {
+  MoneroEncryptedKeyImage,
+  MoneroKeyImageSyncParams,
+  MoneroKeyImageSyncResult,
+  MoneroKeyImageTransfer,
+} from './moneroKeyImageSync';
+export type {
+  MoneroSignTransactionParams,
+  MoneroSignTransactionResult,
+} from './moneroSignTransaction';

package/src/types/api/index.ts

@@ -154,6 +154,12 @@ 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 { moneroGetAddress } from './moneroGetAddress';
+import type { moneroGetWatchKey } from './moneroGetWatchKey';
+import type { moneroKeyImageSync } from './moneroKeyImageSync';
+import type { moneroSignTransaction } from './moneroSignTransaction';
 import type { ConnectSettings } from '../settings';
 import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 
@@ -472,4 +478,18 @@ export type CoreApi = {
    */
   neoGetAddress: typeof neoGetAddress;
   neoSignTransaction: typeof neoSignTransaction;
+
+  /**
+   * Zcash
+   */
+  zcashGetAddress: typeof zcashGetAddress;
+  zcashSignPczt: typeof zcashSignPczt;
+
+  /**
+   * Monero
+   */
+  moneroGetAddress: typeof moneroGetAddress;
+  moneroGetWatchKey: typeof moneroGetWatchKey;
+  moneroKeyImageSync: typeof moneroKeyImageSync;
+  moneroSignTransaction: typeof moneroSignTransaction;
 };

package/src/types/api/moneroGetAddress.ts

@@ -0,0 +1,27 @@
+import type { CommonParams, Response } from '../params';
+
+export type MoneroAddress = {
+  path: string;
+  // Primary address of the account, base58
+  address: string;
+};
+
+export type MoneroGetAddressParams = {
+  // Account path, m/44'/128'/account'
+  path: string | number[];
+  showOnOneKey?: boolean;
+  // 0 mainnet, 1 testnet, 2 stagenet
+  networkType?: number;
+};
+
+export declare function moneroGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & MoneroGetAddressParams
+): Response<MoneroAddress>;
+
+export declare function moneroGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: MoneroGetAddressParams[] }
+): Response<Array<MoneroAddress>>;

package/src/types/api/moneroGetWatchKey.ts

@@ -0,0 +1,28 @@
+import type { CommonParams, Response } from '../params';
+
+export type MoneroWatchKey = {
+  path: string;
+  // Private view key, hex
+  watchKey: string;
+  // Primary address of the account, base58
+  address: string;
+};
+
+export type MoneroGetWatchKeyParams = {
+  // Account path, m/44'/128'/account'
+  path: string | number[];
+  // 0 mainnet, 1 testnet, 2 stagenet
+  networkType?: number;
+};
+
+export declare function moneroGetWatchKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & MoneroGetWatchKeyParams
+): Response<MoneroWatchKey>;
+
+export declare function moneroGetWatchKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: MoneroGetWatchKeyParams[] }
+): Response<Array<MoneroWatchKey>>;

package/src/types/api/moneroKeyImageSync.ts

@@ -0,0 +1,45 @@
+import type { CommonParams, Response } from '../params';
+
+// One owned output, as wallet2 describes it to the device. Keys are 32-byte hex.
+export type MoneroKeyImageTransfer = {
+  // Output public key
+  outKey: string;
+  // Transaction public key R
+  txPubKey: string;
+  // Additional tx public keys: the one for this output, or the whole list
+  additionalTxPubKeys?: string[];
+  // Index of the output within its transaction
+  internalOutputIndex: number;
+  // Receiving subaddress index; omitted means 0 (primary address)
+  subAddrMajor?: number;
+  subAddrMinor?: number;
+};
+
+// ChaCha20-Poly1305 under encKey, hex.
+export type MoneroEncryptedKeyImage = {
+  // 12-byte nonce
+  iv: string;
+  // Ciphertext of key image || signature c || signature r, then the 16-byte tag
+  blob: string;
+};
+
+export type MoneroKeyImageSyncResult = {
+  // Key that decrypts every blob, hex
+  encKey: string;
+  // One entry per transfer, in request order
+  keyImages: MoneroEncryptedKeyImage[];
+};
+
+export type MoneroKeyImageSyncParams = {
+  // Account path, m/44'/128'/account'
+  path: string | number[];
+  // 0 mainnet, 1 testnet, 2 stagenet
+  networkType?: number;
+  transfers: MoneroKeyImageTransfer[];
+};
+
+export declare function moneroKeyImageSync(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & MoneroKeyImageSyncParams
+): Response<MoneroKeyImageSyncResult>;

package/src/types/api/moneroSignTransaction.ts

@@ -0,0 +1,54 @@
+import type { MoneroTransactionData, MoneroTransactionSourceEntry } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type MoneroSignTransactionParams = {
+  // Account path, m/44'/128'/account'
+  path: string | number[];
+  // 0 mainnet, 1 testnet, 2 stagenet
+  networkType?: number;
+  // Init data in protobuf field names; outputs include the change, in final order
+  tsxData: MoneroTransactionData;
+  // One source entry per input, in original order, each with its full ring
+  inputs: MoneroTransactionSourceEntry[];
+};
+
+// Raw device output, hex unless noted. The host assembles the transaction.
+export type MoneroSignTransactionResult = {
+  // Original input index of each sorted input
+  origIndices: number[];
+  // Serialized tx.vin entries, sorted by key image (descending)
+  vinis: string[];
+  // Pseudo-output commitments from SignInputAck, sorted order
+  pseudoOuts: string[];
+  // Sealed CLSAG signatures, sorted order; openingKey unseals them
+  signatures: string[];
+  // Serialized tx.vout entries, output order
+  txOuts: string[];
+  // Output key and commitment (64 bytes each), output order
+  outPks: string[];
+  // Encrypted 8-byte amounts, output order
+  ecdhInfos: string[];
+  // Aggregated Bulletproof+ without V
+  rsig: string;
+  extra: string;
+  txPrefixHash: string;
+  fullMessageHash: string;
+  rv: {
+    // Decimal piconero
+    txnFee: string;
+    message: string;
+    rvType: number;
+  };
+  openingKey: string;
+  // Tx private keys sealed by the device for later proofs (MoneroGetTxKeyRequest), with the
+  // salts that rederive the sealing key; wallet2 keeps them as salt1, salt2, enc_keys
+  salt: string;
+  randMult: string;
+  txEncKeys: string;
+};
+
+export declare function moneroSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & MoneroSignTransactionParams
+): Response<MoneroSignTransactionResult>;

package/src/types/api/zcashGetAddress.ts

@@ -0,0 +1,35 @@
+import type { ZcashAddressScope, ZcashAddressType } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type ZcashAddress = {
+  path: string;
+  // ZIP-316 unified address or transparent P2PKH address
+  address: string;
+  // ZIP-316 unified full viewing key, present when includeUfvk was requested
+  ufvk?: string;
+  // ZIP-32 seed fingerprint (hex), present when includeSeedFingerprint was requested
+  seedFingerprint?: string;
+};
+
+export type ZcashGetAddressParams = {
+  // ZIP-32 account path, m/32'/133'/account'
+  path: string | number[];
+  showOnOneKey?: boolean;
+  diversifierIndex?: number;
+  addressType?: ZcashAddressType;
+  scope?: ZcashAddressScope;
+  includeUfvk?: boolean;
+  includeSeedFingerprint?: boolean;
+};
+
+export declare function zcashGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & ZcashGetAddressParams
+): Response<ZcashAddress>;
+
+export declare function zcashGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: ZcashGetAddressParams[] }
+): Response<Array<ZcashAddress>>;

package/src/types/api/zcashSignPczt.ts

@@ -0,0 +1,18 @@
+import type { CommonParams, Response } from '../params';
+
+export type ZcashSignPcztParams = {
+  // Unproved PCZT (v2, tx v6) as hex; the device signs it and returns a
+  // redacted copy with signatures filled in.
+  pczt: string;
+};
+
+export type ZcashSignedPczt = {
+  // Signed, redacted PCZT as hex
+  pczt: string;
+};
+
+export declare function zcashSignPczt(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & ZcashSignPcztParams
+): Response<ZcashSignedPczt>;

package/src/types/device.ts

@@ -83,6 +83,24 @@ export type SearchDevice = {
   deviceType: IDeviceType;
   name: string;
   commType: OneKeyDeviceCommType;
+  /**
+   * React Native and Electron BLE discovery only. Serial-number color letter ('A'-'Z')
+   * advertised by Pro2 / Neo, possibly remembered from an earlier advertisement in this
+   * process. Absent when unknown; the letter's meaning depends on deviceType.
+   */
+  bleColorCode?: string;
+};
+
+/** 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 = {

package/src/utils/logger.ts

@@ -78,6 +78,10 @@ class Log {
 const _logs: { [k: string]: Log } = {};
 
 export const initLog = (prefix: string, enabled?: boolean) => {
+  // Loggers that share a prefix must share one instance; otherwise enableLog only reaches the
+  // last one registered and the others never print.
+  const existing = _logs[prefix];
+  if (existing) return existing;
   const instance = new Log(prefix, !!enabled);
   _logs[prefix] = instance;
   return instance;