@onekeyfe/hd-core 1.2.8-alpha.9 → 1.2.9

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -6,7 +6,11 @@ import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 import { BaseMethod } from '../BaseMethod';
 import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
-import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+import {
+  createProtocolV2AssetFileWriteRecovery,
+  writeProtocolV2File,
+} from '../helpers/protocolV2FileWrite';
+import { ProtocolV2UiInteractionCoordinator } from '../../protocols/protocol-v2/uiInteraction';
 import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
 import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
 import { LoggerNames, getLogger } from '../../utils';
@@ -142,6 +146,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
       chunkSize: this.params.chunkSize,
       bleChunkSizeLimit,
       maxChunkRetries: 3,
+      recoverConnection: createProtocolV2AssetFileWriteRecovery(this),
       overwrite: true,
       append: false,
       throwIfAborted: () => this.throwIfAborted(),
@@ -171,6 +176,15 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
       data,
       useHostAssetPackage ? WALLPAPER_PACKAGE_BLE_CHUNK_SIZE : undefined
     );
+    this.throwIfAborted();
+    new ProtocolV2UiInteractionCoordinator(this.device, this.postMessage).enterMethodInteraction({
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'device-management',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: this.name,
+    });
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: this.path },
     });

package/src/api/zcash/ZcashGetAddress.ts

@@ -0,0 +1,108 @@
+import { ZcashAddressScope, ZcashAddressType } from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { serializedPath } from '../helpers/pathUtils';
+import { invalidParameter, validateParams, validateResult } from '../helpers/paramsValidator';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateZcashAccountPath } from './helpers';
+
+import type { ZcashGetAddress as HardwareZcashGetAddress } from '@onekeyfe/hd-transport';
+import type { ZcashAddress, ZcashGetAddressParams } from '../../types/api/zcashGetAddress';
+import type { DeviceFirmwareRange } from '../../types';
+
+export default class ZcashGetAddress extends BaseMethod<HardwareZcashGetAddress[]> {
+  hasBundle = false;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: ZcashGetAddressParams) => {
+      const addressN = validateZcashAccountPath(batch.path);
+      const addressType = batch.addressType ?? ZcashAddressType.UNIFIED_ORCHARD_P2PKH;
+      const scope = batch.scope ?? ZcashAddressScope.EXTERNAL;
+      const diversifierIndex = batch.diversifierIndex ?? 0;
+      if (
+        ![
+          ZcashAddressType.UNIFIED_ORCHARD_P2PKH,
+          ZcashAddressType.TRANSPARENT_P2PKH,
+          ZcashAddressType.UNIFIED_ORCHARD,
+        ].includes(addressType) ||
+        ![ZcashAddressScope.EXTERNAL, ZcashAddressScope.INTERNAL].includes(scope)
+      ) {
+        throw invalidParameter('Invalid Zcash address type or scope');
+      }
+      const maxIndex = addressType === ZcashAddressType.UNIFIED_ORCHARD ? 0xffffffff : 0x7fffffff;
+      if (
+        !Number.isSafeInteger(diversifierIndex) ||
+        diversifierIndex < 0 ||
+        diversifierIndex > maxIndex
+      ) {
+        throw invalidParameter('Invalid Zcash diversifier index');
+      }
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'includeSeedFingerprint', type: 'boolean' },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        address_type: addressType,
+        scope,
+        diversifier_index: diversifierIndex,
+        show_display: batch.showOnOneKey ?? true,
+        include_seed_fingerprint: batch.includeSeedFingerprint ?? false,
+      });
+    });
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '1.0.4',
+      },
+    };
+  }
+
+  async run() {
+    const responses: ZcashAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('ZcashGetAddress', 'ZcashAddress', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      // The V2 decoder returns null for absent optional fields; omit them instead.
+      const { address, seed_fingerprint: seedFingerprint } = res.message;
+      responses.push({
+        path,
+        address,
+        ...(seedFingerprint ? { seedFingerprint } : {}),
+      });
+
+      this.postPreviousAddressMessage({ address, path });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/zcash/ZcashGetFullViewingKey.ts

@@ -0,0 +1,78 @@
+import { BaseMethod } from '../BaseMethod';
+import { serializedPath } from '../helpers/pathUtils';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { createMethodInteraction } from '../../protocols/protocol-v2/uiInteraction';
+import { validateZcashAccountPath } from './helpers';
+
+import type { ZcashGetFullViewingKey as HardwareZcashGetFullViewingKey } from '@onekeyfe/hd-transport';
+import type {
+  ZcashFullViewingKey,
+  ZcashGetFullViewingKeyParams,
+} from '../../types/api/zcashGetFullViewingKey';
+import type { DeviceFirmwareRange } from '../../types';
+
+// The device exports the UFVK only after the user confirms it on screen.
+export default class ZcashGetFullViewingKey extends BaseMethod<HardwareZcashGetFullViewingKey[]> {
+  hasBundle = false;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+    // The name matches no Protocol V2 confirmation rule, so the export prompt is declared here.
+    this.protocolV2UiInteraction = createMethodInteraction(
+      'public-key-confirmation',
+      'zcashGetFullViewingKey'
+    );
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: ZcashGetFullViewingKeyParams) => {
+      validateParams(batch, [{ name: 'path', required: true }]);
+      this.params.push({ address_n: validateZcashAccountPath(batch.path) });
+    });
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '1.0.4',
+      },
+    };
+  }
+
+  async run() {
+    // Missing fields stay undefined so validateResult rejects them.
+    const responses: Partial<ZcashFullViewingKey>[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall(
+        'ZcashGetFullViewingKey',
+        'ZcashFullViewingKey',
+        { ...param }
+      );
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        ufvk: res.message.ufvk,
+      });
+    }
+
+    validateResult(responses, ['ufvk'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/zcash/ZcashSignPczt.ts

@@ -0,0 +1,152 @@
+import { bytesToHex } from '@noble/hashes/utils';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { stripHexPrefix } from '../helpers/hexUtils';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ZcashSignPczt as HardwareZcashSignPczt } from '@onekeyfe/hd-transport';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
+import type { ZcashSignedPczt } from '../../types/api/zcashSignPczt';
+import type { DeviceFirmwareRange } from '../../types';
+
+const CHUNK_BYTE_SIZE = 1024;
+// Host memory sanity bound on the device-announced length, not a device limit.
+const SIGNED_PCZT_SANITY_MAX_BYTES = 16 * 1024 * 1024;
+
+export default class ZcashSignPczt extends BaseMethod<HardwareZcashSignPczt> {
+  pczt: Buffer = Buffer.alloc(0);
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    validateParams(this.payload, [{ name: 'pczt', type: 'hexString', required: true }]);
+
+    // Reject odd-length hex instead of left-padding it, which would shift every nibble.
+    const pcztHex = stripHexPrefix(this.payload.pczt);
+    if (pcztHex.length % 2 !== 0) {
+      throw invalidParameter('pczt hex must have an even length');
+    }
+    this.pczt = Buffer.from(pcztHex, 'hex');
+    if (this.pczt.length === 0) {
+      throw invalidParameter('pczt is empty');
+    }
+
+    this.params = {
+      pczt_length: this.pczt.length,
+      pczt_initial_chunk: bytesToHex(this.pczt.subarray(0, CHUNK_BYTE_SIZE)),
+    };
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '1.0.4',
+      },
+    };
+  }
+
+  // Upload: the device decides every chunk length via ZcashPcztChunkRequest and
+  // the host must answer with exactly that many bytes.
+  uploadPczt = async (
+    typedCall: TypedCall,
+    first: TypedResponseMessage<'ZcashSignedPczt'> | TypedResponseMessage<'ZcashPcztChunkRequest'>,
+    initialOffset: number
+  ): Promise<TypedResponseMessage<'ZcashSignedPczt'>> => {
+    let res = first;
+    let offset = initialOffset;
+    while (res.type === 'ZcashPcztChunkRequest') {
+      const { chunk_length: chunkLength } = res.message;
+      if (
+        !Number.isSafeInteger(chunkLength) ||
+        chunkLength <= 0 ||
+        offset + chunkLength > this.pczt.length
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.ResponseUnexpectTypeError,
+          `device requested ${chunkLength} bytes at offset ${offset} of ${this.pczt.length}`
+        );
+      }
+
+      const chunk = this.pczt.subarray(offset, offset + chunkLength);
+      res = await typedCall('ZcashPcztChunkAck', ['ZcashSignedPczt', 'ZcashPcztChunkRequest'], {
+        data_chunk: bytesToHex(chunk),
+      });
+      offset += chunkLength;
+    }
+
+    if (offset !== this.pczt.length) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        'device completed signing before receiving the whole pczt'
+      );
+    }
+    return res;
+  };
+
+  // Download: the host decides chunk lengths via ZcashSignedPcztChunkRequest
+  // until the announced pczt_length has been received.
+  downloadSignedPczt = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'ZcashSignedPczt'>
+  ): Promise<Buffer> => {
+    const { pczt_length: total, pczt_initial_chunk: initial } = res.message;
+    if (!Number.isSafeInteger(total) || total <= 0 || total > SIGNED_PCZT_SANITY_MAX_BYTES) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        `device announced invalid signed pczt length ${total}`
+      );
+    }
+
+    const parts: Buffer[] = [Buffer.from(initial ?? '', 'hex')];
+    let received = parts[0].length;
+    if (received > total) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        'device returned more initial pczt bytes than announced'
+      );
+    }
+
+    while (received < total) {
+      const chunkLength = Math.min(CHUNK_BYTE_SIZE, total - received);
+      const ack = await typedCall('ZcashSignedPcztChunkRequest', 'ZcashPcztChunkAck', {
+        chunk_length: chunkLength,
+      });
+      const chunk = Buffer.from(ack.message.data_chunk ?? '', 'hex');
+      if (chunk.length !== chunkLength) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.ResponseUnexpectTypeError,
+          `device returned ${chunk.length} of ${chunkLength} requested bytes at offset ${received} of ${total}`
+        );
+      }
+      parts.push(chunk);
+      received += chunk.length;
+    }
+
+    return Buffer.concat(parts);
+  };
+
+  async run(): Promise<ZcashSignedPczt> {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const first = await typedCall('ZcashSignPczt', ['ZcashSignedPczt', 'ZcashPcztChunkRequest'], {
+      ...this.params,
+    });
+
+    const signed = await this.uploadPczt(
+      typedCall,
+      first,
+      Math.min(CHUNK_BYTE_SIZE, this.pczt.length)
+    );
+    const pczt = await this.downloadSignedPczt(typedCall, signed);
+
+    return { pczt: bytesToHex(pczt) };
+  }
+}

package/src/api/zcash/helpers.ts

@@ -0,0 +1,16 @@
+import { toHardened, validateStrictPath } from '../helpers/pathUtils';
+import { invalidParameter } from '../helpers/paramsValidator';
+
+// ZIP-32 account path: m/32'/133'/account'
+export function validateZcashAccountPath(path: string | number[]): number[] {
+  const addressN = validateStrictPath(path, 3);
+  if (
+    addressN.length !== 3 ||
+    addressN[0] !== toHardened(32) ||
+    addressN[1] !== toHardened(133) ||
+    addressN[2] < toHardened(0)
+  ) {
+    throw invalidParameter("Zcash requires a ZIP-32 account path m/32'/133'/account'");
+  }
+  return addressN;
+}

package/src/core/index.ts

@@ -1,4 +1,5 @@
 import semver from 'semver';
+import { getOwnedUsbDeviceIdentity } from '../api/SearchDevices';
 import EventEmitter from 'events';
 import {
   DeviceSessionPinType,
@@ -60,6 +61,7 @@ import {
   formatLogMethodLabel,
   getLogBlockLabel,
   getSafeLogPayload,
+  getSafeLogTask,
 } from '../events';
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
@@ -125,6 +127,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 +994,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 +1008,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 +1019,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 +1275,8 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeTimeoutError,
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
           ].includes(error.errorCode)
         ) {
           _deviceList = undefined;
@@ -1360,6 +1364,8 @@ const ensureConnected = async (
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
           ].includes(error.errorCode) ||
@@ -1446,7 +1452,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       };
       for (const requestId of requestIds) {
         const task = requestQueue.getTask(requestId);
-        Log.debug('Cancel Api connect task: ', task);
+        Log.debug('Cancel Api connect task: ', getSafeLogTask(task));
         if (task) {
           // During ensureConnected the method has a connectId but device is
           // assigned only after the poll succeeds. Interrupt the cached BLE
@@ -1481,7 +1487,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       };
       for (const requestId of requestQueue.getRequestTasksId()) {
         const task = requestQueue.getTask(requestId);
-        Log.debug('Cancel Api connect task: ', task);
+        Log.debug('Cancel Api connect task: ', getSafeLogTask(task));
         if (task) {
           interruptDevice(task.method?.device);
           if (task.method.connectId) {
@@ -1826,6 +1832,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
@@ -1940,7 +1950,7 @@ export default class Core extends EventEmitter {
         break;
       }
       case IFRAME.CALLBACK: {
-        Log.log('callback message: ', message);
+        Log.log('callback message: ', getSafeLogPayload(message));
         postMessage(message);
         break;
       }
@@ -1959,6 +1969,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 +2005,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 +2036,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 +2063,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;
 };