@onekeyfe/hd-transport 1.2.0-alpha.20 → 1.2.0-alpha.22

package/src/protocols/v2/session.ts

@@ -1,6 +1,10 @@
-import { PROTOCOL_V2_PACKET_SRC_COMMAND } from '../../constants';
+import {
+  PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS,
+  PROTOCOL_V2_PACKET_SRC_COMMAND,
+} from '../../constants';
 import { ProtocolV2FrameAssembler, concatUint8Arrays } from './frame-assembler';
 import { ProtocolV2SequenceCursor } from './sequence-cursor';
+import { ProtocolV2LinkError } from './errors';
 import { ProtocolV2 } from '..';
 import * as check from '../../utils/highlevel-checks';
 import { LogBlockCommand } from '../../utils/logBlockCommand';
@@ -8,6 +12,8 @@ import { LogBlockCommand } from '../../utils/logBlockCommand';
 import type { Root } from 'protobufjs/light';
 import type { MessageFromOneKey } from '../../types';
 
+export * from './errors';
+
 export type ProtocolV2Schemas = {
   protocolV1: Root;
   protocolV2: Root;
@@ -18,6 +24,7 @@ export type ProtocolV2CallContext = {
   timeoutMs?: number;
   highVolume: boolean;
   generation: number;
+  signal: AbortSignal;
 };
 
 type ProtocolLogger = {
@@ -38,8 +45,6 @@ export type ProtocolV2SessionOptions = {
   createTimeoutError?: (name: string, timeoutMs: number) => Error;
   sequenceCursor?: ProtocolV2SequenceCursor;
   generation?: number;
-  writeTimeoutMs?: number;
-  deliveryTimeoutMs?: number;
 };
 
 export type ProtocolV2CallOptions = {
@@ -116,11 +121,13 @@ export async function withProtocolTimeout<T>(
   promise: Promise<T>,
   timeoutMs: number | undefined,
   createTimeoutError: () => Error,
-  onTimeout?: () => void
+  onTimeout?: () => void,
+  abortSignal?: AbortSignal
 ): Promise<T> {
   if (!timeoutMs) return promise;
 
   let timer: ReturnType<typeof setTimeout> | undefined;
+  let abortHandler: (() => void) | undefined;
   try {
     return await Promise.race([
       promise,
@@ -132,18 +139,29 @@ export async function withProtocolTimeout<T>(
           reject(createTimeoutError());
         }, timeoutMs);
       }),
+      ...(abortSignal
+        ? [
+            new Promise<never>((_, reject) => {
+              abortHandler = () => {
+                reject(new Error('Protocol V2 operation aborted'));
+              };
+              if (abortSignal.aborted) {
+                abortHandler();
+              } else {
+                abortSignal.addEventListener('abort', abortHandler, { once: true });
+              }
+            }),
+          ]
+        : []),
     ]);
   } finally {
     if (timer) clearTimeout(timer);
+    if (abortHandler) {
+      abortSignal?.removeEventListener('abort', abortHandler);
+    }
   }
 }
 
-// A transport write must never keep the serialized device queue pending forever.
-// Callers must classify a timeout as link-fatal and reset the physical adapter so
-// the losing Promise cannot continue on the next connection generation.
-export const PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS = 30_000;
-export const PROTOCOL_V2_DELIVERY_WATCHDOG_TIMEOUT_MS = 5_000;
-
 export class ProtocolV2Session {
   private readonly options: ProtocolV2SessionOptions;
 
@@ -153,6 +171,8 @@ export class ProtocolV2Session {
   // in-flight calls on the same session would steal each other's responses.
   private pendingCall: Promise<unknown> = Promise.resolve();
 
+  private lastResponseSequence?: number;
+
   constructor(options: ProtocolV2SessionOptions) {
     this.options = options;
     this.sequenceCursor = options.sequenceCursor ?? new ProtocolV2SequenceCursor();
@@ -171,7 +191,7 @@ export class ProtocolV2Session {
     return result;
   }
 
-  private async executeCall(
+  private executeCall(
     name: string,
     data: Record<string, unknown>,
     callOptions: ProtocolV2CallOptions
@@ -188,101 +208,106 @@ export class ProtocolV2Session {
       logPrefix = 'ProtocolV2',
       createTimeoutError,
       generation = 0,
-      writeTimeoutMs = PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS,
-      deliveryTimeoutMs = PROTOCOL_V2_DELIVERY_WATCHDOG_TIMEOUT_MS,
     } = this.options;
+    const timeoutMs =
+      callOptions.timeoutMs && callOptions.timeoutMs > 0
+        ? callOptions.timeoutMs
+        : PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS;
+    const abortController = new AbortController();
 
     const shouldReduceDebug = shouldReduceProtocolV2Debug(name);
-    const callContext: ProtocolV2CallContext = {
+    const baseCallContext: ProtocolV2CallContext = {
       messageName: name,
-      timeoutMs: callOptions.timeoutMs,
+      timeoutMs,
       highVolume: shouldReduceDebug,
       generation,
+      signal: abortController.signal,
     };
-    await prepareCall?.(callContext);
-    const protoSeq = this.sequenceCursor.next();
-    const frame = ProtocolV2.encodeFrame(schemas, name, data, {
-      packetSrc,
-      router,
-      seq: protoSeq,
-    });
-    // Suppress Protocol V2 TX frame logs to avoid excessive transport diagnostics.
-    /*
-    const txMetadata = ProtocolV2.inspectFrame(schemas, frame);
-
-    if (!shouldReduceDebug) {
-      logger?.debug?.(`[${logPrefix}] TX`, {
-        method: name,
-        type: name,
-        typeId: txMetadata.messageTypeId,
-        seq: txMetadata.seq,
-        bytes: frame.length,
+
+    const runCall = async (): Promise<MessageFromOneKey> => {
+      await prepareCall?.(baseCallContext);
+      const protoSeq = this.sequenceCursor.next();
+      const frame = ProtocolV2.encodeFrame(schemas, name, data, {
+        packetSrc,
+        router,
+        seq: protoSeq,
       });
-    }
-    */
 
-    if (maxFrameBytes !== undefined && frame.length > maxFrameBytes) {
-      throw new Error(
-        `Protocol V2 frame too large for transport: ${frame.length} > ${maxFrameBytes}`
-      );
-    }
+      if (maxFrameBytes !== undefined && frame.length > maxFrameBytes) {
+        throw new Error(
+          `Protocol V2 frame too large for transport: ${frame.length} > ${maxFrameBytes}`
+        );
+      }
 
-    await withProtocolTimeout(
-      writeFrame(frame, callContext),
-      writeTimeoutMs,
-      () => new Error(`Protocol V2 write timeout after ${writeTimeoutMs}ms for ${name}`)
-    );
+      await writeFrame(frame, baseCallContext);
 
-    // Cancellation flag for the read loop: when the response timeout fires,
-    // Promise.race alone would leave this loop running as a zombie that keeps
-    // consuming frames meant for the next call. The timeout callback flips the
-    // flag so the loop exits and discards any late frame.
-    const cancellation = { cancelled: false };
-    let resolveDelivery: () => void = () => undefined;
-    let deliveryConfirmed = false;
-    const deliveryPromise = new Promise<void>(resolve => {
-      resolveDelivery = () => {
-        if (deliveryConfirmed) return;
-        deliveryConfirmed = true;
-        resolve();
-      };
-    });
-
-    const readResponse = async (): Promise<MessageFromOneKey> => {
       // Some Protocol V2 operations emit progress notifications before the
       // terminal response. Consume those frames here so callers still see a
       // request/terminal-response shaped API.
-      while (!cancellation.cancelled) {
-        const rxFrame = await readFrame(callContext);
-        if (cancellation.cancelled) {
-          // Timed out while waiting: drop the late frame and stop reading.
-          break;
+      while (!abortController.signal.aborted) {
+        const rxFrame = await readFrame(baseCallContext);
+        if (abortController.signal.aborted) break;
+
+        let header: ReturnType<typeof ProtocolV2.inspectFrameHeader>;
+        try {
+          header = ProtocolV2.inspectFrameHeader(rxFrame);
+        } catch (cause) {
+          throw new ProtocolV2LinkError(
+            'frame',
+            `Protocol V2 frame validation failed: ${getErrorMessage(cause)}`,
+            cause
+          );
+        }
+        if (header.router !== router) {
+          throw new ProtocolV2LinkError(
+            'router',
+            `Protocol V2 router mismatch: expected ${router}, got ${header.router}`
+          );
+        }
+        if (header.packetSrc !== packetSrc) {
+          throw new ProtocolV2LinkError(
+            'packet-source',
+            `Protocol V2 packet source mismatch: expected ${packetSrc}, got ${header.packetSrc}`
+          );
+        }
+
+        let isAck: boolean;
+        try {
+          isAck = ProtocolV2.isAckFrame(rxFrame);
+        } catch (cause) {
+          throw new ProtocolV2LinkError(
+            'frame',
+            `Protocol V2 ACK validation failed: ${getErrorMessage(cause)}`,
+            cause
+          );
         }
-        const ackSequence = ProtocolV2.getAckSequence(rxFrame);
-        if (ackSequence !== undefined) {
-          if (ackSequence === protoSeq) {
-            resolveDelivery();
+        if (isAck) {
+          if (header.seq !== protoSeq) {
+            throw new ProtocolV2LinkError(
+              'ack-sequence',
+              `Protocol V2 ACK sequence mismatch: expected ${protoSeq}, got ${header.seq}`
+            );
           }
         } else {
-          // Some firmware versions return the protobuf response without a separate
-          // ACK. Receiving any valid response frame proves that the request arrived.
-          resolveDelivery();
-          // Suppress Protocol V2 RX frame logs to avoid excessive transport diagnostics.
-          /*
-          const rxMetadata = ProtocolV2.inspectFrame(schemas, rxFrame);
-
-          if (!shouldReduceDebug) {
-            logger?.debug?.(`[${logPrefix}] RX`, {
-              method: name,
-              type: rxMetadata.type,
-              typeId: rxMetadata.messageTypeId,
-              seq: rxMetadata.seq,
-              bytes: rxFrame.length,
-            });
+          let decoded: ReturnType<typeof ProtocolV2.decodeFrame>;
+          try {
+            decoded = ProtocolV2.decodeFrame(schemas, rxFrame);
+          } catch (cause) {
+            throw new ProtocolV2LinkError(
+              'frame',
+              `Protocol V2 frame decode failed: ${getErrorMessage(cause)}`,
+              cause
+            );
           }
-          */
-
-          const decoded = ProtocolV2.decodeFrame(schemas, rxFrame);
+          // Firmware owns one TX sequence across all channels and packet sources,
+          // so frames routed elsewhere create valid gaps in this session.
+          if (this.lastResponseSequence === decoded.seq) {
+            throw new ProtocolV2LinkError(
+              'response-sequence',
+              `Protocol V2 duplicate response sequence: ${decoded.seq}`
+            );
+          }
+          this.lastResponseSequence = decoded.seq;
 
           const response = check.call(decoded);
           if (callOptions.intermediateTypes?.includes(response.type)) {
@@ -298,47 +323,21 @@ export class ProtocolV2Session {
           }
         }
       }
-      // Only reachable after cancellation; the outer promise has already been
-      // rejected by the timeout, so this rejection is consumed by the race.
+
       throw new Error(`Protocol V2 read loop cancelled after timeout for ${name}`);
     };
 
-    const responsePromise = withProtocolTimeout(
-      readResponse(),
-      callOptions.timeoutMs,
+    return withProtocolTimeout(
+      runCall(),
+      timeoutMs,
       () =>
         createTimeoutError
-          ? createTimeoutError(name, callOptions.timeoutMs ?? 0)
-          : new Error(`Protocol V2 response timeout after ${callOptions.timeoutMs}ms for ${name}`),
+          ? createTimeoutError(name, timeoutMs)
+          : new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`),
       () => {
-        cancellation.cancelled = true;
+        abortController.abort();
       }
     );
-    const deliverySignal = Promise.race([deliveryPromise, responsePromise.then(() => undefined)]);
-    const deliveryWatchdog = withProtocolTimeout(
-      deliverySignal,
-      deliveryTimeoutMs,
-      () => new Error(`Protocol V2 delivery timeout after ${deliveryTimeoutMs}ms for ${name}`),
-      () => {
-        cancellation.cancelled = true;
-      }
-    );
-
-    try {
-      const firstResult = await Promise.race([
-        deliveryWatchdog.then(() => ({ kind: 'delivered' as const })),
-        responsePromise.then(response => ({ kind: 'response' as const, response })),
-      ]);
-      if (firstResult.kind === 'response') {
-        return firstResult.response;
-      }
-      return await responsePromise;
-    } catch (error) {
-      cancellation.cancelled = true;
-      deliveryWatchdog.catch(() => undefined);
-      responsePromise.catch(() => undefined);
-      throw error;
-    }
   }
 }
 
@@ -367,7 +366,10 @@ export async function probeProtocolV2({
     const response = await call(
       'Ping',
       { message: 'protocol-v2-probe' },
-      { timeoutMs, expectedTypes: ['Success'] }
+      {
+        timeoutMs,
+        expectedTypes: ['Success'],
+      }
     );
     if (response.type === 'Success') {
       return true;

package/src/types/messages.ts

@@ -2359,7 +2359,7 @@ export enum Enum_SafetyCheckLevel {
   PromptAlways = 1,
   PromptTemporarily = 2,
 }
-export type SafetyCheckLevel = keyof typeof Enum_SafetyCheckLevel;
+export type SafetyCheckLevel = keyof typeof Enum_SafetyCheckLevel | Enum_SafetyCheckLevel;
 
 // Initialize
 export type Initialize = {
@@ -4744,7 +4744,9 @@ export type ViewVerifyPage = {
 };
 
 // ProtocolInfoRequest
-export type ProtocolInfoRequest = {};
+export type ProtocolInfoRequest = {
+  eventless_wallet_session?: boolean;
+};
 
 // ProtocolInfo
 export type ProtocolInfo = {
@@ -5049,9 +5051,42 @@ export type ProtocolV2DeviceInfo = {
   status?: DeviceStatus;
 };
 
-// DeviceSessionGet
-export type DeviceSessionGet = {
-  session_id?: string;
+export enum DeviceSessionErrorCode {
+  DeviceSessionError_None = 0,
+  DeviceSessionError_UserCancelled = 1,
+  DeviceSessionError_InvalidSession = 2,
+  DeviceSessionError_AttachPinUnavailable = 3,
+  DeviceSessionError_PassphraseDisabled = 4,
+  DeviceSessionError_Busy = 5,
+}
+
+// DeviceSessionResume
+export type DeviceSessionResume = {
+  session_id: string;
+};
+
+// DeviceSessionHostPassphrase
+export type DeviceSessionHostPassphrase = {
+  passphrase: string;
+};
+
+// DeviceSessionPassphraseOnDevice
+export type DeviceSessionPassphraseOnDevice = {};
+
+// DeviceSessionAttachPinOnDevice
+export type DeviceSessionAttachPinOnDevice = {};
+
+// DeviceSessionSelect
+export type DeviceSessionSelect = {
+  host_passphrase?: DeviceSessionHostPassphrase;
+  passphrase_on_device?: DeviceSessionPassphraseOnDevice;
+  attach_pin_on_device?: DeviceSessionAttachPinOnDevice;
+};
+
+// DeviceSessionOpen
+export type DeviceSessionOpen = {
+  resume?: DeviceSessionResume;
+  select?: DeviceSessionSelect;
 };
 
 // DeviceSession
@@ -5881,7 +5916,12 @@ export type MessageType = {
   DeviceInfoTargets: DeviceInfoTargets;
   DeviceInfoTypes: DeviceInfoTypes;
   DeviceInfoGet: DeviceInfoGet;
-  DeviceSessionGet: DeviceSessionGet;
+  DeviceSessionResume: DeviceSessionResume;
+  DeviceSessionHostPassphrase: DeviceSessionHostPassphrase;
+  DeviceSessionPassphraseOnDevice: DeviceSessionPassphraseOnDevice;
+  DeviceSessionAttachPinOnDevice: DeviceSessionAttachPinOnDevice;
+  DeviceSessionSelect: DeviceSessionSelect;
+  DeviceSessionOpen: DeviceSessionOpen;
   DeviceSession: DeviceSession;
   DeviceSessionAskPin: DeviceSessionAskPin;
   DeviceStatus: DeviceStatus;