@onekeyfe/hd-transport 1.2.0-alpha.23 → 1.2.0-alpha.25

package/messages-protocol-v2.json

@@ -11506,6 +11506,33 @@
         }
       }
     },
+    "UiAnimationType": {
+      "values": {
+        "Unknown": 0,
+        "Signing": 1
+      }
+    },
+    "UiAnimationCommand": {
+      "values": {
+        "CommandUnknown": 0,
+        "Start": 1,
+        "Stop": 2,
+        "Refresh": 3
+      }
+    },
+    "UiAnimationRequest": {
+      "fields": {
+        "command": {
+          "rule": "required",
+          "type": "UiAnimationCommand",
+          "id": 1
+        },
+        "type": {
+          "type": "UiAnimationType",
+          "id": 2
+        }
+      }
+    },
     "ViewAmount": {
       "fields": {
         "is_unlimited": {
@@ -12482,7 +12509,12 @@
       }
     },
     "DeviceSessionAskPassphrase": {
-      "fields": {}
+      "fields": {
+        "passphrase": {
+          "type": "string",
+          "id": 1
+        }
+      }
     },
     "DeviceSessionAskPin_FailureSubCodes": {
       "values": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport",
-  "version": "1.2.0-alpha.23",
+  "version": "1.2.0-alpha.25",
   "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": "7cadb40ca6414053a488756f28a9f413164b235d"
+  "gitHead": "20bb98b8530c509299b9e109d2b5ada7c6a6d034"
 }

package/src/index.ts

@@ -41,9 +41,10 @@ export type {
   OneKeyDeviceInfoBase,
   OneKeyDeviceCommType,
   ProtocolType,
+  TransportDeviceDisconnectEvent,
 } from './types';
 
-export { Messages } from './types';
+export { Messages, TRANSPORT_EVENT } from './types';
 export * from './types/messages';
 export * from './utils/logBlockCommand';
 

package/src/protocols/v2/errors.ts

@@ -1,5 +1,7 @@
 export type ProtocolV2LinkErrorCode =
   | 'response-timeout'
+  | 'io'
+  | 'generation'
   | 'router'
   | 'packet-source'
   | 'ack-sequence'

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

@@ -1,4 +1,5 @@
 import { ProtocolV2SequenceCursor } from './sequence-cursor';
+import { ProtocolV2LinkError } from './errors';
 import { ProtocolV2Session, getErrorMessage } from './session';
 
 import type { MessageFromOneKey, TransportCallOptions } from '../../types';
@@ -40,6 +41,10 @@ export class ProtocolV2LinkManager<Key> {
 
   private readonly callQueues = new Map<Key, Promise<unknown>>();
 
+  private readonly generations = new Map<Key, number>();
+
+  private readonly invalidationReasons = new Map<Key, { generation: number; reason: string }>();
+
   private readonly options: ProtocolV2LinkManagerOptions<Key>;
 
   constructor(options: ProtocolV2LinkManagerOptions<Key>) {
@@ -53,7 +58,11 @@ export class ProtocolV2LinkManager<Key> {
     data: Record<string, unknown>,
     options?: TransportCallOptions
   ): Promise<MessageFromOneKey> {
-    const run = () => this.executeCall(key, createAdapter, name, data, options);
+    const generation = this.generations.get(key) ?? 0;
+    const run = () => {
+      this.assertCallGeneration(key, generation);
+      return this.executeCall(key, createAdapter, name, data, options);
+    };
     const previous = this.callQueues.get(key) ?? Promise.resolve();
     const result = previous.then(run, run);
     const queue = result.catch(() => undefined);
@@ -68,6 +77,10 @@ export class ProtocolV2LinkManager<Key> {
   }
 
   async invalidateLink(key: Key, reason: string): Promise<void> {
+    const generation = (this.generations.get(key) ?? 0) + 1;
+    this.generations.set(key, generation);
+    this.invalidationReasons.set(key, { generation, reason });
+
     const link = this.links.get(key);
     if (!link) return;
 
@@ -78,7 +91,8 @@ export class ProtocolV2LinkManager<Key> {
   }
 
   async invalidateAllLinks(reason: string): Promise<void> {
-    await Promise.all(Array.from(this.links.keys(), key => this.invalidateLink(key, reason)));
+    const keys = new Set([...this.links.keys(), ...this.callQueues.keys()]);
+    await Promise.all(Array.from(keys, key => this.invalidateLink(key, reason)));
   }
 
   async dispose(reason: string): Promise<void> {
@@ -157,4 +171,16 @@ export class ProtocolV2LinkManager<Key> {
       this.callQueues.delete(key);
     }
   }
+
+  private assertCallGeneration(key: Key, generation: number) {
+    const currentGeneration = this.generations.get(key) ?? 0;
+    if (currentGeneration === generation) return;
+
+    const invalidation = this.invalidationReasons.get(key);
+    const reason =
+      invalidation?.generation === currentGeneration
+        ? invalidation.reason
+        : 'Protocol V2 link generation changed';
+    throw new ProtocolV2LinkError('generation', reason);
+  }
 }

package/src/protocols/v2/usb-transport-base.ts

@@ -1,5 +1,7 @@
 import { ProtocolV2FrameAssembler } from './frame-assembler';
+import { ProtocolV2LinkError, isProtocolV2LinkError } from './errors';
 import { ProtocolV2LinkManager } from './link-manager';
+import { getErrorMessage } from './session';
 
 import type { MessageFromOneKey, TransportCallOptions } from '../../types';
 import type { ProtocolV2CallContext, ProtocolV2Schemas, ProtocolV2SessionOptions } from './session';
@@ -32,7 +34,7 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
     this.protocolV2UsbOptions = options;
     this.protocolV2UsbLinks = new ProtocolV2LinkManager<Key>({
       getSchemas: () => this.getProtocolV2UsbSchemas(),
-      classifyError: () => 'link-fatal',
+      classifyError: error => (isProtocolV2LinkError(error) ? 'link-fatal' : 'recoverable'),
       onLinkInvalidated: async (key, reason) => {
         this.protocolV2UsbAssemblers.get(key)?.reset();
         await this.resetProtocolV2UsbNativeLink(key, reason);
@@ -118,10 +120,13 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
 
     const assertCurrentGeneration = () => {
       if (cancellation.reason) {
-        throw new Error(cancellation.reason);
+        throw new ProtocolV2LinkError('generation', cancellation.reason);
       }
       if (this.protocolV2UsbGenerations.get(key) !== generation) {
-        throw new Error('Protocol V2 USB connection generation changed');
+        throw new ProtocolV2LinkError(
+          'generation',
+          'Protocol V2 USB connection generation changed'
+        );
       }
     };
 
@@ -131,11 +136,14 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
       generation,
       prepareCall: () => {
         assertCurrentGeneration();
-        this.getProtocolV2UsbAssembler(key).reset();
       },
       writeFrame: async (frame: Uint8Array, context: ProtocolV2CallContext) => {
         assertCurrentGeneration();
-        await this.writeProtocolV2UsbPacket(key, frame, context);
+        try {
+          await this.writeProtocolV2UsbPacket(key, frame, context);
+        } catch (error) {
+          throw this.createProtocolV2UsbIoError('write', error);
+        }
         assertCurrentGeneration();
       },
       readFrame: async (context: ProtocolV2CallContext) => {
@@ -143,13 +151,15 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
         const assembler = this.getProtocolV2UsbAssembler(key);
         let frame = assembler.push(new Uint8Array(0));
         while (!frame) {
-          const packetRead = this.readProtocolV2UsbPacket(key, context).then(packet => ({
-            packet,
-          }));
+          const packetRead = this.readProtocolV2UsbPacket(key, context)
+            .then(packet => ({ packet }))
+            .catch(error => {
+              throw this.createProtocolV2UsbIoError('read', error);
+            });
           const cancelled = cancellation.promise.then(reason => ({ reason }));
           const result = await Promise.race([packetRead, cancelled]);
           if ('reason' in result) {
-            throw new Error(result.reason);
+            throw new ProtocolV2LinkError('generation', result.reason);
           }
           assertCurrentGeneration();
           frame = assembler.push(result.packet);
@@ -191,4 +201,13 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
     };
     return cancellation;
   }
+
+  private createProtocolV2UsbIoError(operation: 'read' | 'write', error: unknown) {
+    if (isProtocolV2LinkError(error)) return error;
+    return new ProtocolV2LinkError(
+      'io',
+      `Protocol V2 USB ${operation} failed: ${getErrorMessage(error) || 'unknown error'}`,
+      error
+    );
+  }
 }

package/src/types/messages.ts

@@ -4679,6 +4679,24 @@ export enum MoneroNetworkType {
   FAKECHAIN = 3,
 }
 
+export enum UiAnimationType {
+  Unknown = 0,
+  Signing = 1,
+}
+
+export enum UiAnimationCommand {
+  CommandUnknown = 0,
+  Start = 1,
+  Stop = 2,
+  Refresh = 3,
+}
+
+// UiAnimationRequest
+export type UiAnimationRequest = {
+  command: UiAnimationCommand;
+  type?: UiAnimationType;
+};
+
 // ViewAmount
 export type ViewAmount = {
   is_unlimited: boolean;
@@ -5083,7 +5101,9 @@ export type DeviceSessionAskPin = {
 };
 
 // DeviceSessionAskPassphrase
-export type DeviceSessionAskPassphrase = {};
+export type DeviceSessionAskPassphrase = {
+  passphrase?: string;
+};
 
 export enum DeviceSessionAskPin_FailureSubCodes {
   UserCancel = 1,
@@ -5865,6 +5885,7 @@ export type MessageType = {
   Wallpaper: Wallpaper;
   UnlockPath: UnlockPath;
   UnlockedPathRequest: UnlockedPathRequest;
+  UiAnimationRequest: UiAnimationRequest;
   ViewAmount: ViewAmount;
   ViewDetail: ViewDetail;
   ViewTip: ViewTip;

package/src/types/transport.ts

@@ -1,5 +1,15 @@
 import type EventEmitter from 'events';
 
+export const TRANSPORT_EVENT = {
+  DEVICE_DISCONNECT: 'transport-device-disconnect',
+} as const;
+
+export type TransportDeviceDisconnectEvent = {
+  id: string;
+  connectId: string;
+  name: string | null;
+};
+
 export type ProtocolType = 'V1' | 'V2';
 
 export type OneKeyDeviceCommType =