@onekeyfe/hd-transport 1.2.2-alpha.100 → 1.2.2-alpha.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport",
-  "version": "1.2.2-alpha.100",
+  "version": "1.2.2-alpha.102",
   "description": "Transport layer abstractions and utilities for OneKey hardware SDK.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -28,5 +28,5 @@
     "long": "^4.0.0",
     "protobufjs": "^6.11.2"
   },
-  "gitHead": "c40dad085297b0e3cc2020bd218c146dff6ed3e1"
+  "gitHead": "abddc95e03d794d9c6fce7765d59de1f48a684d0"
 }

package/src/constants.ts

@@ -26,7 +26,7 @@ export const PROTOCOL_V2_FRAME_MAX_BYTES = 4200;
 /** FilesystemFileWrite chunk size over WebUSB. */
 export const PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE = 4000;
 
-/** FilesystemFileWrite chunk size over BLE. */
+/** Generic FilesystemFileWrite chunk size over BLE, including support for long filesystem paths. */
 export const PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = 1800;
 
 /**

package/src/protocols/v2/link-manager.ts

@@ -1,6 +1,7 @@
 import { ProtocolV2SequenceCursor } from './sequence-cursor';
 import { ProtocolV2LinkError } from './errors';
 import { ProtocolV2Session, getErrorMessage } from './session';
+import { PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS } from '../../constants';
 
 import type { MessageFromOneKey, TransportCallOptions } from '../../types';
 import type { ProtocolV2CallContext, ProtocolV2Schemas, ProtocolV2SessionOptions } from './session';
@@ -61,15 +62,45 @@ export class ProtocolV2LinkManager<Key> {
     options?: TransportCallOptions
   ): Promise<MessageFromOneKey> {
     const generation = this.generations.get(key) ?? 0;
+    const previousQueue = this.callQueues.get(key);
+    const timeoutMs =
+      options?.timeoutMs && options.timeoutMs > 0
+        ? options.timeoutMs
+        : PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS;
+    const queuedAt = Date.now();
+    let queueTimeout: ReturnType<typeof setTimeout> | undefined;
+    let queueTimeoutError: Error | undefined;
+    const timeoutWhileQueued = new Promise<never>((_, reject) => {
+      queueTimeout = setTimeout(() => {
+        queueTimeout = undefined;
+        queueTimeoutError = this.createQueuedCallTimeoutError(key, name, timeoutMs);
+        reject(queueTimeoutError);
+      }, timeoutMs);
+    });
     const run = () => {
+      if (queueTimeout) {
+        clearTimeout(queueTimeout);
+        queueTimeout = undefined;
+      }
+      if (queueTimeoutError) {
+        throw queueTimeoutError;
+      }
       this.assertCallGeneration(key, generation);
-      return this.executeCall(key, createAdapter, name, data, options);
+      const remainingTimeoutMs = previousQueue ? timeoutMs - (Date.now() - queuedAt) : timeoutMs;
+      if (remainingTimeoutMs <= 0) {
+        throw this.createQueuedCallTimeoutError(key, name, timeoutMs);
+      }
+      return this.executeCall(key, createAdapter, name, data, {
+        ...options,
+        timeoutMs: remainingTimeoutMs,
+      });
     };
-    const previous = this.callQueues.get(key) ?? Promise.resolve();
-    const result = previous.then(run, run);
-    const queue = result.catch(() => undefined);
+    const previous = previousQueue ?? Promise.resolve();
+    const execution = previous.then(run, run);
+    const result = Promise.race([execution, timeoutWhileQueued]);
+    const queue = execution.catch(() => undefined);
     this.callQueues.set(key, queue);
-    result
+    execution
       .then(
         () => this.clearSettledCallQueue(key, queue),
         () => this.clearSettledCallQueue(key, queue)
@@ -206,6 +237,16 @@ export class ProtocolV2LinkManager<Key> {
     }
   }
 
+  private createQueuedCallTimeoutError(key: Key, name: string, timeoutMs: number): Error {
+    const adapterTimeoutError = this.links.get(key)?.adapter.createTimeoutError;
+    return adapterTimeoutError
+      ? adapterTimeoutError(name, timeoutMs)
+      : new ProtocolV2LinkError(
+          'response-timeout',
+          `Protocol V2 call timeout after ${timeoutMs}ms while queued for ${name}`
+        );
+  }
+
   private assertCallGeneration(key: Key, generation: number) {
     const currentGeneration = this.generations.get(key) ?? 0;
     if (currentGeneration === generation) return;

package/src/protocols/v2/session.ts

@@ -60,6 +60,7 @@ export type ProtocolV2CallOptions = {
   onIntermediateResponse?: (response: MessageFromOneKey) => void;
   onWriteCompleted?: (metrics: TransportWriteMetrics) => void;
   returnAfterWrite?: boolean;
+  onResponseAfterWrite?: (response: MessageFromOneKey) => void;
   writeWithResponse?: boolean;
 };
 
@@ -81,6 +82,33 @@ export function hexToBytes(hex: string): Uint8Array {
   return bytes;
 }
 
+export function detectProtocolV2LinkDisabledError({
+  schemas,
+  assembler,
+  bytes,
+}: {
+  schemas: ProtocolV2Schemas;
+  assembler: ProtocolV2FrameAssembler;
+  bytes: Uint8Array;
+}) {
+  try {
+    for (const frame of assembler.drain(bytes)) {
+      const response = check.call(ProtocolV2.decodeFrame(schemas, frame));
+      if (response.type === 'Failure') {
+        const failureCode = response.message?.code;
+        const firmwareMessage = response.message?.message;
+        if (isProtocolV2LinkDisabledFailure(failureCode, firmwareMessage)) {
+          return createProtocolV2LinkDisabledError(failureCode, firmwareMessage);
+        }
+      }
+    }
+  } catch {
+    // Cross-protocol detection may receive a normal Protocol V1 notification.
+    assembler.reset();
+  }
+  return undefined;
+}
+
 export function bytesToHex(bytes: Uint8Array): string {
   return Array.from(bytes)
     .map(b => b.toString(16).padStart(2, '0'))
@@ -199,6 +227,11 @@ export class ProtocolV2Session {
   // response, but their frames must never interleave with the active request write.
   private pendingWrite: Promise<unknown> = Promise.resolve();
 
+  private pendingResponseAfterWrite?: {
+    expectedTypes: Set<string>;
+    onResponse?: (response: MessageFromOneKey) => void;
+  };
+
   private lastResponseSequence?: number;
 
   constructor(options: ProtocolV2SessionOptions) {
@@ -297,7 +330,11 @@ export class ProtocolV2Session {
     };
 
     const runCall = async (): Promise<MessageFromOneKey> => {
-      await prepareCall?.(baseCallContext);
+      // A write-only call may still have a terminal response in flight. Preserve
+      // the continuous receive queue until the next call consumes that response.
+      if (!this.pendingResponseAfterWrite) {
+        await prepareCall?.(baseCallContext);
+      }
       const protoSeq = this.sequenceCursor.next();
       const frame = ProtocolV2.encodeFrame(schemas, name, data, {
         packetSrc,
@@ -323,6 +360,12 @@ export class ProtocolV2Session {
       }
 
       if (callOptions.returnAfterWrite) {
+        if (callOptions.expectedTypes?.length) {
+          this.pendingResponseAfterWrite = {
+            expectedTypes: new Set(callOptions.expectedTypes),
+            onResponse: callOptions.onResponseAfterWrite,
+          };
+        }
         return { type: 'WriteCompleted', message: {} };
       }
 
@@ -395,7 +438,26 @@ export class ProtocolV2Session {
           this.lastResponseSequence = decoded.seq;
 
           const response = check.call(decoded);
-          if (callOptions.intermediateTypes?.includes(response.type)) {
+          const { pendingResponseAfterWrite } = this;
+          let belongsToWriteOnlyCall = false;
+          if (pendingResponseAfterWrite) {
+            belongsToWriteOnlyCall = pendingResponseAfterWrite.expectedTypes.has(response.type);
+            if (belongsToWriteOnlyCall || COMMON_TERMINAL_RESPONSE_TYPES.has(response.type)) {
+              this.pendingResponseAfterWrite = undefined;
+              if (belongsToWriteOnlyCall) {
+                try {
+                  pendingResponseAfterWrite.onResponse?.(response);
+                } catch (error) {
+                  logger?.error?.(
+                    `${logPrefix} delayed response callback failed: ${String(error)}`
+                  );
+                }
+              }
+            }
+          }
+          if (belongsToWriteOnlyCall) {
+            // The delayed response belongs to the preceding write-only call.
+          } else if (callOptions.intermediateTypes?.includes(response.type)) {
             callOptions.onIntermediateResponse?.(response);
           } else if (isExpectedTerminalResponse(response, callOptions.expectedTypes)) {
             return response;
@@ -433,6 +495,7 @@ export async function probeProtocolV2({
   logPrefix = 'ProtocolV2',
   onBeforeProbe,
   onProbeFailed,
+  shouldRethrow,
 }: {
   call: (
     name: string,
@@ -444,6 +507,7 @@ export async function probeProtocolV2({
   logPrefix?: string;
   onBeforeProbe?: () => Promise<void> | void;
   onProbeFailed?: (error: unknown) => Promise<void> | void;
+  shouldRethrow?: (error: unknown) => boolean;
 }) {
   let probeError: unknown;
   try {
@@ -468,7 +532,7 @@ export async function probeProtocolV2({
     }
     probeError = new Error(`unexpected response type ${response.type}`);
   } catch (error) {
-    if (isProtocolV2LinkDisabledError(error)) {
+    if (isProtocolV2LinkDisabledError(error) || shouldRethrow?.(error)) {
       throw error;
     }
     probeError = error;

package/src/types/messages.ts

@@ -1950,6 +1950,7 @@ export type EthereumSignTxOneKey = {
   data_length?: number;
   chain_id: number;
   tx_type?: number;
+  expected_address?: string;
 };
 
 // EthereumAccessListOneKey
@@ -1971,6 +1972,7 @@ export type EthereumSignTxEIP1559OneKey = {
   data_length: number;
   chain_id: number;
   access_list: EthereumAccessListOneKey[];
+  expected_address?: string;
 };
 
 // EthereumAuthorizationSignature
@@ -3824,6 +3826,7 @@ export type SolanaSignedTx = {
 
 export enum SolanaOffChainMessageVersion {
   MESSAGE_VERSION_0 = 0,
+  MESSAGE_VERSION_1 = 1,
 }
 
 export enum SolanaOffChainMessageFormat {
@@ -3838,6 +3841,7 @@ export type SolanaSignOffChainMessage = {
   message_version?: SolanaOffChainMessageVersion;
   message_format?: SolanaOffChainMessageFormat;
   application_domain?: string;
+  required_signers: string[];
 };
 
 // SolanaSignUnsafeMessage
@@ -4550,12 +4554,6 @@ export enum CommandFlags {
   Factory_Only = 1,
 }
 
-// experimental_message
-export type experimental_message = {};
-
-// experimental_field
-export type experimental_field = {};
-
 export type TextMemo = {
   text: string;
 };
@@ -4660,6 +4658,12 @@ export type UiAnimationRequest = {
   type?: UiAnimationType;
 };
 
+// experimental_message
+export type experimental_message = {};
+
+// experimental_field
+export type experimental_field = {};
+
 // ProtocolInfoRequest
 export type ProtocolInfoRequest = {
   eventless_wallet_session?: boolean;
@@ -4766,6 +4770,19 @@ export type DeviceMiscUsbMscControl = {
   enable: boolean;
 };
 
+// DeviceFindMyTokenUpdate
+export type DeviceFindMyTokenUpdate = {
+  token: string;
+};
+
+// DeviceFindMyTokenStateGet
+export type DeviceFindMyTokenStateGet = {};
+
+// DeviceFindMyTokenState
+export type DeviceFindMyTokenState = {
+  burned: boolean;
+};
+
 export enum DeviceFactoryAck {
   FACTORY_ACK_SUCCESS = 0,
   FACTORY_ACK_FAIL = 1,
@@ -4788,15 +4805,19 @@ export type DeviceFactoryInfo = {
   factory_test_completed?: boolean;
   factory_burn_in_completed?: boolean;
   manufacture_time?: DeviceFactoryInfoManufactureTime;
+  data?: string;
 };
 
 // DeviceFactoryInfoSet
 export type DeviceFactoryInfoSet = {
   info: DeviceFactoryInfo;
+  full_data?: boolean;
 };
 
 // DeviceFactoryInfoGet
-export type DeviceFactoryInfoGet = {};
+export type DeviceFactoryInfoGet = {
+  full_data?: boolean;
+};
 
 // DeviceFactoryPermanentLock
 export type DeviceFactoryPermanentLock = {
@@ -4837,6 +4858,12 @@ export enum DeviceFirmwareUpdateTaskStatus {
   FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS = 10,
 }
 
+export enum DeviceFirmwareUpdatePhase {
+  FW_MGMT_UPDATER_PHASE_PREPARE = 0,
+  FW_MGMT_UPDATER_PHASE_INSTALL = 1,
+  FW_MGMT_UPDATER_PHASE_VERIFY = 2,
+}
+
 // DeviceFirmwareTarget
 export type DeviceFirmwareTarget = {
   target_id: DeviceFirmwareTargetType;
@@ -4849,12 +4876,22 @@ export type DeviceFirmwareUpdateStage = {
 };
 
 // DeviceFirmwareUpdateRequest
-export type DeviceFirmwareUpdateRequest = {};
+export type DeviceFirmwareUpdateRequest = {
+  reboot_after_update?: boolean;
+};
+
+// DeviceFirmwareUpdatePhaseInfo
+export type DeviceFirmwareUpdatePhaseInfo = {
+  phase: DeviceFirmwareUpdatePhase;
+  progress_percent: number;
+};
 
 // DeviceFirmwareUpdateRecord
 export type DeviceFirmwareUpdateRecord = {
   target_id: DeviceFirmwareTargetType;
   status?: DeviceFirmwareUpdateTaskStatus;
+  progress_percent?: number;
+  phase_info?: DeviceFirmwareUpdatePhaseInfo;
   payload_version?: number;
   path?: string;
 };
@@ -4862,6 +4899,8 @@ export type DeviceFirmwareUpdateRecord = {
 // DeviceFirmwareUpdateRecordFields
 export type DeviceFirmwareUpdateRecordFields = {
   status?: boolean;
+  progress_percent?: boolean;
+  phase_info?: boolean;
   payload_version?: boolean;
   path?: boolean;
 };
@@ -4992,13 +5031,13 @@ export enum DeviceSessionSeedDomain {
 export type DeviceSessionGet = {
   session_id?: string;
   btc_test_address?: string;
-  seed_domains: DeviceSessionSeedDomain[];
 };
 
 // DeviceSession
 export type DeviceSession = {
   session_id?: string;
   btc_test_address?: string;
+  seed_domains: DeviceSessionSeedDomain[];
 };
 
 export enum DeviceSessionPinType {
@@ -5016,6 +5055,7 @@ export type DeviceSessionAskPin = {
 export type DeviceSessionAskPassphrase = {
   passphrase?: string;
   on_device: boolean;
+  seed_domains: DeviceSessionSeedDomain[];
 };
 
 export enum DeviceSessionAskPin_FailureSubCodes {
@@ -5207,6 +5247,12 @@ export type ViewDetail = {
   has_icon: boolean;
 };
 
+// ViewCustomField
+export type ViewCustomField = {
+  key: string;
+  value: string;
+};
+
 export enum ViewTipType {
   Default = 0,
   Highlight = 1,
@@ -5220,12 +5266,33 @@ export type ViewTip = {
   type: ViewTipType;
   text?: string;
   text_id?: number;
+  text_arg?: string;
 };
 
-// ViewRawData
-export type ViewRawData = {
+// ViewActionCard
+export type ViewActionCard = {
   initial_data: string;
-  placeholder: number;
+};
+
+// ViewContentPreview
+export type ViewContentPreview = {
+  content_key: number;
+  preview: string;
+  total_bytes?: number;
+};
+
+// ViewContentEntry
+export type ViewContentEntry = {
+  entry_key: number;
+  value: string;
+};
+
+// ViewContentPage
+export type ViewContentPage = {
+  page_index: number;
+  page_count: number;
+  chunk?: string;
+  entry?: ViewContentEntry;
 };
 
 export enum ViewSignLayout {
@@ -5243,10 +5310,21 @@ export type ViewSignPage = {
   amount?: UintType;
   general: ViewDetail[];
   tip?: ViewTip;
-  raw_data?: ViewRawData;
+  action_card?: ViewActionCard;
   slide_to_confirm?: boolean;
   layout?: ViewSignLayout;
   title_id?: number;
+  title_arg?: string;
+  content?: ViewContentPreview;
+  custom_field?: ViewCustomField;
+};
+
+// ViewWarningPage
+export type ViewWarningPage = {
+  title_id: number;
+  text_id: number;
+  text_arg?: string;
+  cancellable?: boolean;
 };
 
 // ViewVerifyPage
@@ -5259,6 +5337,7 @@ export type ViewVerifyPage = {
   value_key?: number;
   title_id?: number;
   chain_id?: number;
+  content?: ViewContentPreview;
 };
 
 export enum ProtocolV2FailureType {
@@ -5858,8 +5937,6 @@ export type MessageType = {
   TronSignMessage: TronSignMessage;
   TronMessageSignature: TronMessageSignature;
   facotry: facotry;
-  experimental_message: experimental_message;
-  experimental_field: experimental_field;
   TextMemo: TextMemo;
   RefundMemo: RefundMemo;
   CoinPurchaseMemo: CoinPurchaseMemo;
@@ -5875,6 +5952,8 @@ export type MessageType = {
   UnlockPath: UnlockPath;
   UnlockedPathRequest: UnlockedPathRequest;
   UiAnimationRequest: UiAnimationRequest;
+  experimental_message: experimental_message;
+  experimental_field: experimental_field;
   ProtocolInfoRequest: ProtocolInfoRequest;
   ProtocolInfo: ProtocolInfo;
   DeviceReboot: DeviceReboot;
@@ -5888,6 +5967,9 @@ export type MessageType = {
   DeviceCertificateSignature: DeviceCertificateSignature;
   DeviceCertificateSign: DeviceCertificateSign;
   DeviceMiscUsbMscControl: DeviceMiscUsbMscControl;
+  DeviceFindMyTokenUpdate: DeviceFindMyTokenUpdate;
+  DeviceFindMyTokenStateGet: DeviceFindMyTokenStateGet;
+  DeviceFindMyTokenState: DeviceFindMyTokenState;
   DeviceFactoryInfoManufactureTime: DeviceFactoryInfoManufactureTime;
   DeviceFactoryInfo: DeviceFactoryInfo;
   DeviceFactoryInfoSet: DeviceFactoryInfoSet;
@@ -5897,6 +5979,7 @@ export type MessageType = {
   DeviceFirmwareTarget: DeviceFirmwareTarget;
   DeviceFirmwareUpdateStage: DeviceFirmwareUpdateStage;
   DeviceFirmwareUpdateRequest: DeviceFirmwareUpdateRequest;
+  DeviceFirmwareUpdatePhaseInfo: DeviceFirmwareUpdatePhaseInfo;
   DeviceFirmwareUpdateRecord: DeviceFirmwareUpdateRecord;
   DeviceFirmwareUpdateRecordFields: DeviceFirmwareUpdateRecordFields;
   DeviceFirmwareUpdateStatusGet: DeviceFirmwareUpdateStatusGet;
@@ -5935,9 +6018,14 @@ export type MessageType = {
   PortfolioUpdate: PortfolioUpdate;
   ViewAmount: ViewAmount;
   ViewDetail: ViewDetail;
+  ViewCustomField: ViewCustomField;
   ViewTip: ViewTip;
-  ViewRawData: ViewRawData;
+  ViewActionCard: ViewActionCard;
+  ViewContentPreview: ViewContentPreview;
+  ViewContentEntry: ViewContentEntry;
+  ViewContentPage: ViewContentPage;
   ViewSignPage: ViewSignPage;
+  ViewWarningPage: ViewWarningPage;
   ViewVerifyPage: ViewVerifyPage;
 };
 

package/src/types/transport.ts

@@ -59,6 +59,8 @@ export type AcquireInput = {
    * transport must probe the protocol on the wire, bypassing any cached result.
    */
   forceProtocolDetection?: boolean;
+  /** Reuse expectedProtocol only when this transport previously confirmed it for the same endpoint. */
+  skipProtocolProbe?: boolean;
 };
 
 export type MessageFromOneKey = { type: string; message: Record<string, any> };
@@ -77,6 +79,8 @@ export type TransportCallOptions = {
   onWriteCompleted?: (metrics: TransportWriteMetrics) => void;
   /** Resolve after the complete request frame is written without waiting for a response. */
   returnAfterWrite?: boolean;
+  /** Observe the delayed terminal response of a write-only call while a later call is active. */
+  onResponseAfterWrite?: (response: MessageFromOneKey) => void;
   /** Prefer acknowledged BLE characteristic writes for this call when supported. */
   writeWithResponse?: boolean;
 };
@@ -141,6 +145,8 @@ export type LowlevelTransportSharedPlugin = {
   receive: (uuid?: string) => Promise<string>;
   connect: (uuid: string) => Promise<void>;
   disconnect: (uuid: string) => Promise<void>;
+  /** Maximum Protocol V2 bytes accepted by one BLE characteristic write. */
+  getProtocolV2PacketCapacity?: (uuid: string) => number | undefined | Promise<number | undefined>;
 
   init: () => Promise<void>;
   version: string;