@onekeyfe/hd-core 1.2.0-alpha.4 → 1.2.0-alpha.40

package/src/api/nexa/NexaGetAddress.ts

@@ -45,10 +45,6 @@ export default class NexaGetAddress extends BaseMethod<HardwareNexaGetAddress[]>
 
   getVersionRange(): DeviceFirmwareRange {
     return {
-      pro2: {
-        min: '0.0.0',
-        unsupported: true,
-      },
       model_mini: {
         min: '3.2.0',
       },

package/src/api/nexa/NexaSignTransaction.ts

@@ -9,6 +9,8 @@ import type { TypedCall } from '@onekeyfe/hd-transport';
 import type { DeviceFirmwareRange, NexaSignTransactionParams, NexaSignature } from '../../types';
 
 export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
+  checkDeviceId = true;
+
   hasBundle = false;
 
   init() {
@@ -29,10 +31,6 @@ export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionP
 
   getVersionRange(): DeviceFirmwareRange {
     return {
-      pro2: {
-        min: '0.0.0',
-        unsupported: true,
-      },
       model_mini: {
         min: '3.2.0',
       },
@@ -73,7 +71,7 @@ export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionP
       const nextIndex = res.message.request_index;
       const input = this.params.inputs[nextIndex];
       const response = await typedCall('NexaTxInputAck', ['NexaTxInputRequest', 'NexaSignedTx'], {
-        // path 为字符串形式，归一为 address_n 数组（与 run() 中首个 input 的处理一致）
+        // Normalize a string path to address_n, matching the first input handled by run().
         address_n: validatePath(input.path, 3),
         raw_message: input.message,
       });

package/src/api/nostr/NostrDecryptMessage.ts

@@ -6,6 +6,10 @@ import { validateParams } from '../helpers/paramsValidator';
 import type { NostrDecryptMessage as DecryptMessage } from '@onekeyfe/hd-transport';
 
 export default class NostrDecryptMessage extends BaseMethod<DecryptMessage> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/nostr/NostrEncryptMessage.ts

@@ -6,6 +6,10 @@ import { validateParams } from '../helpers/paramsValidator';
 import type { NostrEncryptMessage as EncryptMessage } from '@onekeyfe/hd-transport';
 
 export default class NostrEncryptMessage extends BaseMethod<EncryptMessage> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/nostr/NostrGetPublicKey.ts

@@ -8,6 +8,10 @@ import type { BTCGetAddressParams } from '../../types/api/btcGetAddress';
 import type { NostrPublicKey } from '../../types/api/nostrGetPublicKey';
 
 export default class NostrGetPublicKey extends BaseMethod<GetPublicKey[]> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/nostr/NostrSignEvent.ts

@@ -10,6 +10,10 @@ import { bytesToHex, hexToBytes } from '../helpers/hexUtils';
 import type { NostrSignEvent as SignEvent } from '@onekeyfe/hd-transport';
 
 export default class NostrSignEvent extends BaseMethod<SignEvent> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/nostr/NostrSignSchnorr.ts

@@ -6,6 +6,10 @@ import { validateParams } from '../helpers/paramsValidator';
 import type { NostrSignSchnorr as SignSchnorr } from '@onekeyfe/hd-transport';
 
 export default class NostrSignSchnorr extends BaseMethod<SignSchnorr> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/polkadot/PolkadotGetAddress.ts

@@ -7,6 +7,10 @@ import type { PolkadotGetAddress as HardwarePolkadotGetAddress } from '@onekeyfe
 import type { PolkadotAddress, PolkadotGetAddressParams } from '../../types';
 
 export default class PolkadotGetAddress extends BaseMethod<HardwarePolkadotGetAddress[]> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/polkadot/PolkadotSignTransaction.ts

@@ -8,6 +8,10 @@ import type { PolkadotSignTransactionParams } from '../../types';
 import type { PolkadotSignTx as HardwarePolkadotSignTx } from '@onekeyfe/hd-transport';
 
 export default class PolkadotSignTransaction extends BaseMethod<HardwarePolkadotSignTx> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

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

@@ -1,9 +1,12 @@
 import { BaseMethod } from '../BaseMethod';
 
 export default class DeviceFactoryInfoGet extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.params = undefined;

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

@@ -3,9 +3,12 @@ import { BaseMethod } from '../BaseMethod';
 import type { DeviceFactoryInfoSetParams } from './helpers';
 
 export default class DeviceFactoryInfoSet extends BaseMethod<DeviceFactoryInfoSetParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.params = {

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

@@ -12,9 +12,12 @@ import type { MessageFromOneKey } from '@onekeyfe/hd-transport';
 import type { DeviceFirmwareUpdateParams } from './helpers';
 
 export default class DeviceFirmwareUpdate extends BaseMethod<DeviceFirmwareUpdateParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.params = {
@@ -48,12 +51,12 @@ export default class DeviceFirmwareUpdate extends BaseMethod<DeviceFirmwareUpdat
           },
         }
       );
-      return Promise.resolve(res.message);
+      return res.message;
     } catch (error) {
       if (isProtocolV2DeviceDisconnectedError(error)) {
-        return Promise.resolve({
+        return {
           message: 'Device firmware update started',
-        });
+        };
       }
       throw error;
     }

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

@@ -1,19 +1,57 @@
 import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+import type { DeviceFirmwareUpdateStatusGetParams } from './helpers';
+import type { DeviceFirmwareUpdateRecordFields } from '@onekeyfe/hd-transport';
+
+const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = ['status', 'payload_version', 'path'] as const;
+
+function normalizeStatusFields(
+  fields: DeviceFirmwareUpdateStatusGetParams['fields']
+): DeviceFirmwareUpdateRecordFields | undefined {
+  if (fields === undefined || fields === null) return undefined;
+  if (typeof fields !== 'object' || Array.isArray(fields)) {
+    throw invalidParameter('Parameter [fields] must be an object.');
+  }
+
+  const unknownField = Object.keys(fields).find(
+    field => !DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS.includes(field as any)
+  );
+  if (unknownField) {
+    throw invalidParameter(`Unsupported firmware update status field: ${unknownField}`);
+  }
+
+  const normalized: DeviceFirmwareUpdateRecordFields = {};
+  for (const field of DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS) {
+    const value = fields[field];
+    if (value !== undefined) {
+      if (typeof value !== 'boolean') {
+        throw invalidParameter(`Parameter [fields.${field}] must be a boolean.`);
+      }
+      normalized[field] = value;
+    }
+  }
+  return normalized;
+}
+
+export default class DeviceGetFirmwareUpdateStatus extends BaseMethod<DeviceFirmwareUpdateStatusGetParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
 
-export default class DeviceGetFirmwareUpdateStatus extends BaseMethod {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.params = undefined;
+    const fields = normalizeStatusFields(this.payload.fields);
+    this.params = fields ? { fields } : {};
   }
 
   async run() {
     const res = await this.device.commands.typedCall(
       'DeviceFirmwareUpdateStatusGet',
       'DeviceFirmwareUpdateStatus',
-      {}
+      this.params
     );
     return Promise.resolve(res.message);
   }

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

@@ -0,0 +1,21 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceGetOnboardingStatus extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'OnboardingStatusGet',
+      'OnboardingStatus',
+      {}
+    );
+    return message;
+  }
+}

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

@@ -1,5 +1,3 @@
-import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
-
 import { UI_REQUEST } from '../../constants/ui-request';
 import { PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS } from '../../protocols/protocol-v2';
 import { BaseMethod } from '../BaseMethod';
@@ -13,7 +11,6 @@ export type DeviceInfoGetTargets = {
   se2?: boolean;
   se3?: boolean;
   se4?: boolean;
-  status?: boolean;
 };
 
 export type DeviceInfoGetTypes = {
@@ -36,7 +33,6 @@ const TARGET_KEYS: (keyof DeviceInfoGetTargets)[] = [
   'se2',
   'se3',
   'se4',
-  'status',
 ];
 
 const TYPE_KEYS: (keyof DeviceInfoGetTypes)[] = ['version', 'build_id', 'hash', 'specific'];
@@ -45,7 +41,6 @@ const DEFAULT_TARGETS: DeviceInfoGetTargets = {
   hw: true,
   fw: true,
   coprocessor: true,
-  status: true,
 };
 
 const DEFAULT_TYPES: DeviceInfoGetTypes = {
@@ -103,19 +98,21 @@ function normalizeTypes(value: unknown): DeviceInfoGetTypes | undefined {
 }
 
 /**
- * 原生 DeviceInfoGet（Protocol V2 only）。
+ * Raw DeviceInfoGet command for Protocol V2 only.
  *
- * 与 getDeviceInfo 不同：不构建 DeviceProfile、不更新设备缓存，
- * 按调用方给定的 targets/types 原样请求并返回未加工的 DeviceInfo 消息，
- * 用于调试固件字段上报。
+ * The SDK builds targets/types on demand and returns the raw DeviceInfo message.
+ * This command is internal; integrations should use getDeviceState.
  */
 export default class DeviceInfoGet extends BaseMethod<{
   targets: DeviceInfoGetTargets;
   types: DeviceInfoGetTypes;
 }> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'none';
     this.allowDeviceMode = [
       ...this.allowDeviceMode,
       UI_REQUEST.NOT_INITIALIZE,
@@ -130,10 +127,6 @@ export default class DeviceInfoGet extends BaseMethod<{
   }
 
   async run() {
-    if (!this.device.isProtocolV2()) {
-      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-    }
-
     const res = await this.device.commands.typedCall(
       'DeviceInfoGet',
       'DeviceInfo',

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

@@ -4,9 +4,11 @@ import { normalizeRebootType } from './helpers';
 import type { DeviceRebootParams } from './helpers';
 
 export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.params = {
@@ -16,9 +18,11 @@ export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
   }
 
   async run() {
+    const rebootType = normalizeRebootType(this.params.reboot_type ?? this.params.rebootType);
     const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
-      reboot_type: normalizeRebootType(this.params.reboot_type ?? this.params.rebootType),
+      reboot_type: rebootType,
     });
+    this.device.markProtocolV2Reboot(rebootType);
     return Promise.resolve(res.message);
   }
 }

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

@@ -0,0 +1,19 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceStatusGet extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.unlockPolicy = 'none';
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
+    this.device.updateProtocolV2Status(message);
+    return message;
+  }
+}

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

@@ -0,0 +1,166 @@
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
+import {
+  PRO2_NFT_DEFAULT_CHUNK_SIZE,
+  PRO2_NFT_DEFAULT_PACE_MS,
+  PRO2_NFT_DEFAULT_TIMEOUT_MS,
+  PRO2_NFT_DIRECTORY,
+  PRO2_NFT_MAX_CHUNK_SIZE,
+  PRO2_NFT_MIN_CHUNK_SIZE,
+  type Pro2NftBundle,
+  type Pro2NftImage,
+  buildPro2NftBundle,
+} from '../../utils/pro2Nft';
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+import { isProtocolV2ResponseTimeout, writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+
+export type DeviceUploadNftParams = {
+  image: Pro2NftImage;
+  thumbnail: Pro2NftImage;
+  title: string;
+  subtitle: string;
+  timestampMs?: number;
+  chunkSize?: number;
+  paceMs?: number;
+  timeoutMs?: number;
+};
+
+export type DeviceUploadNftResponse = {
+  basename: string;
+  imagePath: string;
+  thumbnailPath: string;
+  metadataPath: string;
+  totalSize: number;
+  nftUpdated: true;
+  message?: string;
+};
+
+const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
+const NFT_UPDATE_MESSAGE_TYPE = 61500;
+
+export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
+  private bundle?: Pro2NftBundle;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    const {
+      image,
+      thumbnail,
+      title,
+      subtitle,
+      timestampMs = Date.now(),
+      chunkSize = PRO2_NFT_DEFAULT_CHUNK_SIZE,
+      paceMs = PRO2_NFT_DEFAULT_PACE_MS,
+      timeoutMs = PRO2_NFT_DEFAULT_TIMEOUT_MS,
+    } = this.payload;
+    if (
+      !Number.isInteger(chunkSize) ||
+      chunkSize < PRO2_NFT_MIN_CHUNK_SIZE ||
+      chunkSize > PRO2_NFT_MAX_CHUNK_SIZE
+    ) {
+      throw invalidParameter(
+        `Parameter [chunkSize] must be an integer between ${PRO2_NFT_MIN_CHUNK_SIZE} and ${PRO2_NFT_MAX_CHUNK_SIZE}.`
+      );
+    }
+    if (!Number.isInteger(paceMs) || paceMs < 0) {
+      throw invalidParameter('Parameter [paceMs] must be a non-negative integer.');
+    }
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+      throw invalidParameter('Parameter [timeoutMs] must be a positive integer.');
+    }
+
+    this.bundle = buildPro2NftBundle({ image, thumbnail, title, subtitle, timestampMs });
+    this.params = { image, thumbnail, title, subtitle, timestampMs, chunkSize, paceMs, timeoutMs };
+    this.unlockPolicy = 'none';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  private async assertCapabilities() {
+    const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
+    const hasFileWrite = supportsProtocolV2Message(
+      protocolInfo,
+      FILESYSTEM_FILE_WRITE_MESSAGE_TYPE
+    );
+    const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
+    if (!hasFileWrite || !hasNftUpdate) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+  }
+
+  private async updateNft(basename: string) {
+    const params = { file_name_no_ext: basename };
+    const options = { timeoutMs: this.params.timeoutMs };
+    try {
+      return await this.device.commands.typedCall('NftUpdate', 'Success', params, options);
+    } catch (error) {
+      if (!isProtocolV2ResponseTimeout(error)) {
+        throw error;
+      }
+      this.throwIfAborted();
+      return this.device.commands.typedCall('NftUpdate', 'Success', params, options);
+    }
+  }
+
+  async run(): Promise<DeviceUploadNftResponse> {
+    const { bundle } = this;
+    if (!bundle) throw invalidParameter('NFT data has not been initialized.');
+
+    await this.assertCapabilities();
+
+    const files = [
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
+    ];
+    const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
+    let transferredBeforeFile = 0;
+
+    for (const file of files) {
+      const transferredAtFileStart = transferredBeforeFile;
+      await writeProtocolV2File({
+        commands: this.device.commands,
+        path: file.path,
+        data: file.data,
+        totalSize: file.data.byteLength,
+        chunkSize: this.params.chunkSize,
+        timeoutMs: this.params.timeoutMs,
+        paceMs: this.params.paceMs,
+        overwrite: true,
+        append: false,
+        throwIfAborted: () => this.throwIfAborted(),
+        onProgress: progress => {
+          if (typeof this.postMessage !== 'function') return;
+          const transferredBytes = transferredAtFileStart + progress.transferredBytes;
+          this.postMessage(
+            createUiMessage(UI_REQUEST.DEVICE_PROGRESS, {
+              ...progress,
+              progress: Math.floor((transferredBytes / totalSize) * 100),
+              transferredBytes,
+              totalBytes: totalSize,
+            })
+          );
+        },
+      });
+      transferredBeforeFile += file.data.byteLength;
+    }
+
+    this.throwIfAborted();
+    const response = await this.updateNft(bundle.basename);
+    return {
+      basename: bundle.basename,
+      imagePath: files[0].path,
+      thumbnailPath: files[1].path,
+      metadataPath: files[2].path,
+      totalSize,
+      nftUpdated: true,
+      message: response.message?.message,
+    };
+  }
+}