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

package/src/protocols/v2/decode.ts

@@ -61,13 +61,6 @@ export function isAckFrame(data: Uint8Array): boolean {
   return true;
 }
 
-export function getAckSequence(data: Uint8Array): number | undefined {
-  if (!isAckFrame(data)) {
-    return undefined;
-  }
-  return data[6];
-}
-
 /**
  * Parse and validate a Protocol V2 response frame.
  *

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

@@ -17,7 +17,6 @@ export interface ProtocolV2LinkAdapter {
   logger?: ProtocolV2SessionOptions['logger'];
   logPrefix?: string;
   createTimeoutError?: ProtocolV2SessionOptions['createTimeoutError'];
-  writeTimeoutMs?: number;
 }
 
 export type ProtocolV2LinkManagerOptions<Key> = {
@@ -129,7 +128,6 @@ export class ProtocolV2LinkManager<Key> {
       logger: adapter.logger,
       logPrefix: adapter.logPrefix,
       createTimeoutError: adapter.createTimeoutError,
-      writeTimeoutMs: adapter.writeTimeoutMs,
     });
     const link = { adapter, session, state };
     this.links.set(key, link);

package/src/protocols/v2/session.ts

@@ -38,8 +38,6 @@ export type ProtocolV2SessionOptions = {
   createTimeoutError?: (name: string, timeoutMs: number) => Error;
   sequenceCursor?: ProtocolV2SequenceCursor;
   generation?: number;
-  writeTimeoutMs?: number;
-  deliveryTimeoutMs?: number;
 };
 
 export type ProtocolV2CallOptions = {
@@ -138,12 +136,6 @@ export async function withProtocolTimeout<T>(
   }
 }
 
-// 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;
 
@@ -188,8 +180,6 @@ 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 shouldReduceDebug = shouldReduceProtocolV2Debug(name);
@@ -227,26 +217,13 @@ export class ProtocolV2Session {
       );
     }
 
-    await withProtocolTimeout(
-      writeFrame(frame, callContext),
-      writeTimeoutMs,
-      () => new Error(`Protocol V2 write timeout after ${writeTimeoutMs}ms for ${name}`)
-    );
+    await writeFrame(frame, callContext);
 
     // 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
@@ -258,15 +235,8 @@ export class ProtocolV2Session {
           // Timed out while waiting: drop the late frame and stop reading.
           break;
         }
-        const ackSequence = ProtocolV2.getAckSequence(rxFrame);
-        if (ackSequence !== undefined) {
-          if (ackSequence === protoSeq) {
-            resolveDelivery();
-          }
-        } else {
-          // Some firmware versions return the protobuf response without a separate
-          // ACK. Receiving any valid response frame proves that the request arrived.
-          resolveDelivery();
+        const isAck = ProtocolV2.isAckFrame(rxFrame);
+        if (!isAck) {
           // Suppress Protocol V2 RX frame logs to avoid excessive transport diagnostics.
           /*
           const rxMetadata = ProtocolV2.inspectFrame(schemas, rxFrame);
@@ -303,7 +273,7 @@ export class ProtocolV2Session {
       throw new Error(`Protocol V2 read loop cancelled after timeout for ${name}`);
     };
 
-    const responsePromise = withProtocolTimeout(
+    return withProtocolTimeout(
       readResponse(),
       callOptions.timeoutMs,
       () =>
@@ -314,31 +284,6 @@ export class ProtocolV2Session {
         cancellation.cancelled = true;
       }
     );
-    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;
-    }
   }
 }
 

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 = {