@onekeyfe/hd-core 1.2.0-alpha.16 → 1.2.0-alpha.18

package/src/data/messages/messages.json

@@ -6082,7 +6082,6 @@
           }
         },
         "raw_message": {
-          "rule": "required",
           "type": "bytes",
           "id": 2
         },
@@ -6113,6 +6112,42 @@
           "options": {
             "default": true
           }
+        },
+        "output_count": {
+          "type": "uint32",
+          "id": 7
+        },
+        "version": {
+          "type": "uint32",
+          "id": 8,
+          "options": {
+            "default": 0
+          }
+        },
+        "lock_time": {
+          "type": "uint64",
+          "id": 9,
+          "options": {
+            "default": 0
+          }
+        },
+        "subnetwork_id": {
+          "type": "bytes",
+          "id": 10
+        },
+        "gas": {
+          "type": "uint64",
+          "id": 11,
+          "options": {
+            "default": 0
+          }
+        },
+        "payload_length": {
+          "type": "uint32",
+          "id": 12,
+          "options": {
+            "default": 0
+          }
         }
       }
     },
@@ -6146,6 +6181,249 @@
         }
       }
     },
+    "KaspaOutpoint": {
+      "fields": {
+        "tx_id": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        },
+        "index": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        }
+      }
+    },
+    "KaspaInputScriptType": {
+      "values": {
+        "KASPA_SPEND_P2PK_SCHNORR": 0,
+        "KASPA_SPEND_P2PK_ECDSA": 1
+      }
+    },
+    "KaspaOutputScriptType": {
+      "values": {
+        "KASPA_PAYTOADDRESS": 0,
+        "KASPA_PAYTOCHANGE": 1
+      }
+    },
+    "KaspaRequestType": {
+      "values": {
+        "KASPA_TX_INPUT": 0,
+        "KASPA_TX_OUTPUT": 1,
+        "KASPA_TX_PAYLOAD": 2,
+        "KASPA_TX_FINISHED": 3,
+        "KASPA_TX_PREV_META": 4
+      }
+    },
+    "KaspaTxRequestSignature": {
+      "fields": {
+        "signature_index": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "signature": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "KaspaTxRequest": {
+      "fields": {
+        "request_type": {
+          "rule": "required",
+          "type": "KaspaRequestType",
+          "id": 1
+        },
+        "request_index": {
+          "type": "uint32",
+          "id": 2
+        },
+        "signature": {
+          "type": "KaspaTxRequestSignature",
+          "id": 3
+        },
+        "request_payload_length": {
+          "type": "uint32",
+          "id": 4
+        },
+        "prev_tx_id": {
+          "type": "bytes",
+          "id": 5
+        }
+      }
+    },
+    "KaspaTxAckInput": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "previous_outpoint": {
+          "rule": "required",
+          "type": "KaspaOutpoint",
+          "id": 2
+        },
+        "amount": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 3
+        },
+        "sequence": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 4
+        },
+        "sig_op_count": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 5
+        },
+        "script_type": {
+          "type": "KaspaInputScriptType",
+          "id": 6,
+          "options": {
+            "default": "KASPA_SPEND_P2PK_SCHNORR"
+          }
+        },
+        "use_tweak": {
+          "type": "bool",
+          "id": 9,
+          "options": {
+            "default": true
+          }
+        }
+      }
+    },
+    "KaspaTxAckOutput": {
+      "fields": {
+        "script_type": {
+          "type": "KaspaOutputScriptType",
+          "id": 1,
+          "options": {
+            "default": "KASPA_PAYTOADDRESS"
+          }
+        },
+        "amount": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 2
+        },
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 3,
+          "options": {
+            "packed": false
+          }
+        },
+        "address": {
+          "type": "string",
+          "id": 4
+        },
+        "scheme": {
+          "type": "string",
+          "id": 7,
+          "options": {
+            "default": "schnorr"
+          }
+        },
+        "use_tweak": {
+          "type": "bool",
+          "id": 8,
+          "options": {
+            "default": true
+          }
+        }
+      }
+    },
+    "KaspaTxAckPayloadChunk": {
+      "fields": {
+        "payload_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
+    "KaspaTxAckPrevMeta": {
+      "fields": {
+        "version": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "input_count": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        },
+        "output_count": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 3
+        },
+        "lock_time": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 4
+        },
+        "subnetwork_id": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 5
+        },
+        "gas": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 6
+        },
+        "payload_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 7
+        }
+      }
+    },
+    "KaspaTxAckPrevInput": {
+      "fields": {
+        "previous_outpoint": {
+          "rule": "required",
+          "type": "KaspaOutpoint",
+          "id": 1
+        },
+        "sequence": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 2
+        }
+      }
+    },
+    "KaspaTxAckPrevOutput": {
+      "fields": {
+        "amount": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 1
+        },
+        "script_version": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        },
+        "script_public_key": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 3
+        }
+      }
+    },
     "KaspaSignedTx": {
       "fields": {
         "signature": {
@@ -12559,6 +12837,13 @@
         "MessageType_KaspaSignedTx": 11303,
         "MessageType_KaspaTxInputRequest": 11304,
         "MessageType_KaspaTxInputAck": 11305,
+        "MessageType_KaspaTxRequest": 11306,
+        "MessageType_KaspaTxAckInput": 11307,
+        "MessageType_KaspaTxAckOutput": 11308,
+        "MessageType_KaspaTxAckPayloadChunk": 11309,
+        "MessageType_KaspaTxAckPrevMeta": 11310,
+        "MessageType_KaspaTxAckPrevInput": 11311,
+        "MessageType_KaspaTxAckPrevOutput": 11312,
         "MessageType_NexaGetAddress": 11400,
         "MessageType_NexaAddress": 11401,
         "MessageType_NexaSignTx": 11402,

package/src/device/Device.ts

@@ -52,8 +52,8 @@ import TransportManager from '../data-manager/TransportManager';
 import { toHardened } from '../api/helpers/pathUtils';
 import { existCapability } from '../utils/capabilitieUtils';
 import {
-  PROTOCOL_V2_STATUS_DEVICE_INFO_REQUEST,
   requestProtocolV2DeviceInfo,
+  requestProtocolV2DeviceStatus,
 } from '../protocols/protocol-v2/features';
 import { buildProtocolV1FeaturesPayload, buildProtocolV2FeaturesPayload } from '../deviceProfile';
 
@@ -96,7 +96,8 @@ const Log = getLogger(LoggerNames.Device);
 
 export interface DeviceEvents {
   [DEVICE.PIN]: [Device, PROTO.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
-  [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
+  [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, PassphraseRequestPayload?];
+  [DEVICE.ATTACH_PIN_ON_DEVICE]: [Device, PassphraseRequestPayload?];
   [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
   [DEVICE.FEATURES]: [Device, DeviceFeaturesPayload];
   [DEVICE.PASSPHRASE]: [
@@ -728,10 +729,8 @@ export class Device extends EventEmitter {
         if (this.features.bootloaderMode) {
           return;
         }
-        // 不能直接信任缓存 features：设备端 wipe / 完成初始化 / 改 label 后
-        // features 会永久陈旧。每次 run 做一次轻量 status 刷新（不含 fw/SE），
-        // 用字段级合并保留已有版本和 SE 信息。
-        await this._refreshProtocolV2Status(options);
+        // 普通业务调用复用缓存。动态状态由显式 getFeatures/deviceStatusGet、
+        // 解锁流程和设备事件刷新，避免每个 SDK 方法都额外轮询 DeviceStatus。
         return;
       }
       await this._initializeProtocolV2(options);
@@ -798,9 +797,15 @@ export class Device extends EventEmitter {
         commands: this.commands,
         timeoutMs: options?.protocolV2DeviceInfoTimeoutMs,
       });
+      const deviceStatus = await requestProtocolV2DeviceStatus({
+        commands: this.commands,
+      }).catch(error => {
+        Log.debug('Protocol V2 status unavailable during initialization:', error);
+        return undefined;
+      });
       // 默认请求不含 SE/hash 数据，scope 如实标注为 basic；
       // 完整数据由 getDeviceInfo(scope:'verify'|'full') 获取。
-      const features = this.updateProtocolV2Features(deviceInfo);
+      const features = this.updateProtocolV2Features(deviceInfo, deviceStatus);
       Log.debug('Protocol V2 features:', features);
       this.featuresNeedsReload = false;
     } catch (error) {
@@ -809,34 +814,15 @@ export class Device extends EventEmitter {
     }
   }
 
-  /**
-   * Protocol V2 的轻量状态刷新（每次 run 前调用）。
-   *
-   * 请求 hw + coprocessor + status（不含 fw/SE target）：status 提供 init_states / label /
-   * passphrase_enabled 等会在设备端变化的字段；hw/coprocessor 提供 serialNo / bleName。
-   * versions 为空时按字段级合并保留旧值，verify 数据不会被降级。
-   */
-  private async _refreshProtocolV2Status(options?: InitOptions) {
-    try {
-      const deviceInfo = await requestProtocolV2DeviceInfo({
-        commands: this.commands,
-        request: PROTOCOL_V2_STATUS_DEVICE_INFO_REQUEST,
-        timeoutMs: options?.protocolV2DeviceInfoTimeoutMs,
-      });
-      const features = this.updateProtocolV2Features(deviceInfo);
-      Log.debug('Protocol V2 features (status refresh):', features);
-    } catch (error) {
-      Log.error('Protocol V2 status refresh failed:', error);
-      throw error;
-    }
-  }
-
   async getFeatures() {
     if (this.isProtocolV2()) {
       const deviceInfo = await requestProtocolV2DeviceInfo({
         commands: this.commands,
       });
-      return this.updateProtocolV2Features(deviceInfo);
+      const deviceStatus = await requestProtocolV2DeviceStatus({
+        commands: this.commands,
+      }).catch(() => undefined);
+      return this.updateProtocolV2Features(deviceInfo, deviceStatus);
     }
 
     const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
@@ -871,10 +857,18 @@ export class Device extends EventEmitter {
     this.emit(DEVICE.FEATURES, this, feat);
   }
 
-  updateProtocolV2Features(deviceInfo?: ProtocolV2DeviceInfo) {
+  updateProtocolV2Features(deviceInfo?: ProtocolV2DeviceInfo, deviceStatus?: DeviceStatus | null) {
     const previousCacheDeviceKey = this.getSessionCacheDeviceKey();
+    const resolvedDeviceStatus =
+      deviceStatus === undefined
+        ? this.features?.raw?.protocolV2DeviceStatus
+        : deviceStatus ?? undefined;
     const features = fixFeaturesFirmwareVersion(
-      buildProtocolV2FeaturesPayload(deviceInfo, this.features)
+      buildProtocolV2FeaturesPayload({
+        deviceInfo,
+        deviceStatus: resolvedDeviceStatus,
+        previous: this.features,
+      })
     );
     this.features = features;
     const nextCacheDeviceKey = this.getSessionCacheDeviceKey();
@@ -888,14 +882,10 @@ export class Device extends EventEmitter {
 
   updateProtocolV2Status(status: DeviceStatus) {
     const previousDeviceInfo = this.features?.raw?.protocolV2DeviceInfo;
-    const previousStatus = previousDeviceInfo?.status;
-    return this.updateProtocolV2Features({
-      ...(previousDeviceInfo ?? {}),
-      protocol_version: previousDeviceInfo?.protocol_version ?? this.features?.protocolVersion ?? 2,
-      status: {
-        ...previousStatus,
-        ...status,
-      },
+    const previousStatus = this.features?.raw?.protocolV2DeviceStatus;
+    return this.updateProtocolV2Features(previousDeviceInfo, {
+      ...previousStatus,
+      ...status,
     });
   }
 
@@ -1190,7 +1180,9 @@ export class Device extends EventEmitter {
   async unlockDevice() {
     if (this.isProtocolV2()) {
       try {
-        await this.commands.typedCall('DeviceSessionAskPin', 'Success');
+        await this.commands.typedCall('DeviceSessionAskPin', 'Success', undefined, {
+          timeoutMs: 120_000,
+        });
       } catch (error) {
         const errorText =
           error instanceof Error

package/src/device/DeviceCommands.ts

@@ -663,7 +663,7 @@ export class DeviceCommands {
 
     if (res.type === 'PassphraseRequest') {
       const existsAttachPinUser = res.message.exists_attach_pin_user;
-      return this._promptPassphrase({
+      return this.promptPassphrase({
         existsAttachPinUser,
       }).then(response => {
         const { passphrase, passphraseOnDevice, attachPinOnDevice } = response;
@@ -761,10 +761,27 @@ export class DeviceCommands {
     });
   }
 
-  _promptPassphrase(options: PassphraseRequestPayload) {
+  promptPassphrase(
+    options: PassphraseRequestPayload,
+    promptOptions: { cancelDeviceOnReject?: boolean } = {}
+  ) {
     return new Promise<PassphrasePromptResponse>((resolve, reject) => {
-      const cancelAndReject = (_error?: Error) =>
-        cancelDeviceInPrompt(this.device, false)
+      const cancelAndReject = (_error?: Error) => {
+        const rejectWithCancelledError = () => {
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.CallQueueActionCancelled,
+              `${DEVICE.PASSPHRASE} canceled`
+            )
+          );
+        };
+
+        if (promptOptions.cancelDeviceOnReject === false) {
+          rejectWithCancelledError();
+          return Promise.resolve();
+        }
+
+        return cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
               HardwareErrorCode.CallQueueActionCancelled,
@@ -781,6 +798,7 @@ export class DeviceCommands {
           .catch(error => {
             reject(error);
           });
+      };
 
       if (this.device.listenerCount(DEVICE.PASSPHRASE) > 0) {
         this.device.setCancelableAction(cancelAndReject);

package/src/device/DevicePool.ts

@@ -108,14 +108,19 @@ export class DevicePool extends EventEmitter {
           device.updateDescriptor(exist, true);
           devices[connectId] = device;
           deviceList.push(device);
-          await this._checkDevicePool(initOptions);
+          await this._checkDevicePool(initOptions, connectId);
           return { devices, deviceList };
         }
         Log.debug('found device in cache, but path is different: ', connectId);
       }
     }
 
-    for await (const descriptor of descriptorList) {
+    const matchedDescriptor = connectId
+      ? descriptorList.find(descriptor => descriptor.path === connectId)
+      : undefined;
+    const descriptorsToInitialize = matchedDescriptor ? [matchedDescriptor] : descriptorList;
+
+    for await (const descriptor of descriptorsToInitialize) {
       const device = await this._createDevice(descriptor, initOptions);
 
       const connectId = device.getConnectId();
@@ -133,7 +138,7 @@ export class DevicePool extends EventEmitter {
     // Log.debug('get devices result : ', devices, deviceList);
     // console.log('device poll -> connected: ', this.connectedPool);
     // console.log('device poll -> disconnected: ', this.disconnectPool);
-    await this._checkDevicePool(initOptions);
+    await this._checkDevicePool(initOptions, matchedDescriptor ? connectId : undefined);
     return { devices, deviceList };
   }
 
@@ -157,14 +162,17 @@ export class DevicePool extends EventEmitter {
     return device;
   }
 
-  static async _checkDevicePool(initOptions?: InitOptions) {
-    await this._sendConnectMessage(initOptions);
+  static async _checkDevicePool(initOptions?: InitOptions, connectId?: string) {
+    await this._sendConnectMessage(initOptions, connectId);
     this._sendDisconnectMessage();
   }
 
-  static async _sendConnectMessage(initOptions?: InitOptions) {
+  static async _sendConnectMessage(initOptions?: InitOptions, connectId?: string) {
     for (let i = this.connectedPool.length - 1; i >= 0; i--) {
       const descriptor = this.connectedPool[i];
+      if (connectId && descriptor.path !== connectId) {
+        continue;
+      }
       const device = await this._createDevice(descriptor, initOptions);
       Log.debug('emit DEVICE.CONNECT: ', device?.features);
       this.emitter.emit(DEVICE.CONNECT, device);

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -5,7 +5,11 @@ import {
   isProtocolV2RomloaderDeviceInfo,
 } from '../protocols/protocol-v2/features';
 
-import type { DeviceFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type {
+  DeviceFirmwareImageInfo,
+  DeviceStatus,
+  ProtocolV2DeviceInfo,
+} from '@onekeyfe/hd-transport';
 import type { PROTO } from '../constants';
 import type { DeviceFeaturesMode, Features } from '../types';
 
@@ -222,16 +226,21 @@ export const buildProtocolV1FeaturesPayload = (
  * 缓存的同名字段级合并；不存在协议等价语义的字段保持 null/空值，不再通过
  * DeviceProfile 或 transport path 做身份兜底。
  */
-export const buildProtocolV2FeaturesPayload = (
-  deviceInfo?: ProtocolV2DeviceInfo,
-  previous?: Features
-): Features => {
+export const buildProtocolV2FeaturesPayload = ({
+  deviceInfo,
+  deviceStatus,
+  previous,
+}: {
+  deviceInfo?: ProtocolV2DeviceInfo;
+  deviceStatus?: DeviceStatus;
+  previous?: Features;
+}): Features => {
   const info = deviceInfo;
   const fwApplication = info?.fw?.application;
   const fwBootloader = info?.fw?.bootloader;
   const fwBoard = info?.fw?.romloader;
   const bleApplication = info?.coprocessor?.application;
-  const status = info?.status;
+  const status = deviceStatus;
 
   const firmwareVersion = firstMeaningfulVersion(
     getImageVersion(fwApplication),
@@ -248,15 +257,17 @@ export const buildProtocolV2FeaturesPayload = (
   const label = previous?.label ?? null;
   const bleName = firstValue(info?.coprocessor?.bt_adv_name, previous?.bleName);
   const initialized = firstValue(status?.init_states, previous?.initialized) ?? null;
-  const passphraseProtection = status?.passphrase_enabled ?? null;
+  // Pro2 在锁定状态下返回的 passphrase_enabled 不是最终钱包状态。
+  // 只有完成 PIN 解锁后的 DeviceStatus 才能作为 passphrase 开关真值来源。
+  const passphraseProtection = status?.unlocked === true ? status.passphrase_enabled ?? null : null;
   const language = previous?.language ?? null;
   const backupRequired = firstValue(status?.backup_required, previous?.backupRequired) ?? null;
   const bleEnabled = previous?.bleEnabled;
   const unlocked = firstValue(status?.unlocked, previous?.unlocked) ?? null;
   const attachToPinEnabled = status?.attach_to_pin_enabled ?? null;
   const unlockedAttachPin = status?.unlocked_by_attach_to_pin ?? undefined;
-  const romloaderMode = isProtocolV2RomloaderDeviceInfo(info);
-  const bootloaderMode = isProtocolV2BootloaderDeviceInfo(info);
+  const romloaderMode = isProtocolV2RomloaderDeviceInfo(info, status);
+  const bootloaderMode = isProtocolV2BootloaderDeviceInfo(info, status);
   let mode: DeviceFeaturesMode = 'unknown';
   if (romloaderMode) {
     mode = 'romloader';
@@ -376,6 +387,7 @@ export const buildProtocolV2FeaturesPayload = (
     unlockedAttachPin,
     raw: {
       protocolV2DeviceInfo: deviceInfo,
+      protocolV2DeviceStatus: deviceStatus,
     },
   };
 };