@onekeyfe/hd-transport-web-device 1.2.0-alpha.2 → 1.2.0-alpha.21

package/__tests__/electron-ble-transport.test.ts

@@ -1,4 +1,5 @@
 import transport, { PROTOCOL_V2_CHANNEL_BLE_UART, bytesToHex } from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import ElectronBleTransport from '../src/electron-ble-transport';
 
@@ -28,21 +29,25 @@ const protocolV1Schema = {
 
 const protocolV2Schema = {
   nested: {
-    GetProtoVersion: {
+    ProtocolInfoRequest: {
       fields: {},
     },
-    ProtoVersion: {
+    ProtocolInfo: {
       fields: {
-        major_version: {
+        version: {
           type: 'uint32',
           id: 1,
         },
-        minor_version: {
+        supported_messages: {
+          rule: 'repeated',
           type: 'uint32',
           id: 2,
+          options: {
+            packed: false,
+          },
         },
-        patch_version: {
-          type: 'uint32',
+        protobuf_definition: {
+          type: 'string',
           id: 3,
         },
       },
@@ -65,8 +70,8 @@ const protocolV2Schema = {
     },
     MessageType: {
       values: {
-        MessageType_GetProtoVersion: 60200,
-        MessageType_ProtoVersion: 60201,
+        MessageType_ProtocolInfoRequest: 60200,
+        MessageType_ProtocolInfo: 60201,
         MessageType_Ping: 60206,
         MessageType_Success: 60207,
       },
@@ -241,6 +246,95 @@ describe('ElectronBleTransport protocol detection', () => {
       );
       expect(nobleBle.write).toHaveBeenCalledTimes(1);
       expect(transport.getProtocolType(device.id)).toBe('V2');
+      await expect(transport.call(device.id, 'Ping', { message: 'after-probe' })).resolves.toEqual({
+        type: 'Success',
+        message: { message: 'ok' },
+      });
+      const sentSeqs = nobleBle.write.mock.calls.map(([, hex]) =>
+        Number.parseInt(hex.slice(12, 14), 16)
+      );
+      expect(sentSeqs).toEqual([1, 2]);
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('rejects the active Protocol V2 reader when pairing is rejected', async () => {
+    const device = { id: 'pairing-rejected-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    let pairingRejected = false;
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      setTimeout(
+        () =>
+          notificationHandler?.(
+            device.id,
+            pairingRejected ? 'PAIRING_REJECTED' : bytesToHex(probeResponse)
+          ),
+        0
+      );
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await transport.acquire({ uuid: device.id });
+      pairingRejected = true;
+
+      await expect(
+        transport.call(device.id, 'Ping', { message: 'pairing' }, { timeoutMs: 50 })
+      ).rejects.toMatchObject({ errorCode: HardwareErrorCode.BleDeviceBondedCanceled });
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('rebuilds the active link when Core acquires the same device again', async () => {
+    const device = { id: 'repeated-acquire-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    const response = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await transport.acquire({ uuid: device.id });
+      await transport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+      await expect(
+        transport.call(device.id, 'Ping', { message: 'after-reacquire' })
+      ).resolves.toEqual({
+        type: 'Success',
+        message: { message: 'ok' },
+      });
+
+      const sentSeqs = nobleBle.write.mock.calls.map(([, hex]) =>
+        Number.parseInt(hex.slice(12, 14), 16)
+      );
+      expect(sentSeqs).toEqual([1, 2]);
     } finally {
       await transport.release(device.id);
     }

package/__tests__/webusb-protocol-v2-timeout.test.ts

@@ -0,0 +1,63 @@
+import transport, { ProtocolV2FrameAssembler } from '@onekeyfe/hd-transport';
+
+import WebUsbTransport from '../src/webusb';
+
+const schema = {
+  nested: {
+    Ping: { fields: { message: { type: 'string', id: 1 } } },
+    Success: { fields: { message: { type: 'string', id: 1 } } },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+describe('WebUsbTransport Protocol V2 timeout recovery', () => {
+  test('resets the connection between a failed V1 probe and the V2 probe', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro2-webusb';
+    const events: string[] = [];
+    webusb.probeProtocolV1 = jest.fn().mockImplementation(() => {
+      events.push('probe-v1');
+      return Promise.resolve(false);
+    });
+    webusb.resetConnectionAfterProbe = jest.fn().mockImplementation(() => {
+      events.push('reset');
+      return Promise.resolve();
+    });
+    webusb.probeProtocolV2 = jest.fn().mockImplementation(() => {
+      events.push('probe-v2');
+      return Promise.resolve(true);
+    });
+
+    await expect(webusb.detectProtocol(path)).resolves.toBe('V2');
+
+    expect(events).toEqual(['probe-v1', 'reset', 'probe-v2']);
+    expect(webusb.deviceProtocol.get(path)).toBe('V2');
+  });
+
+  test('invalidates and resets the cached connection before another call can start', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro2-webusb';
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    webusb.protocolV2Assemblers.set(path, new ProtocolV2FrameAssembler());
+    webusb.transferOutOnce = jest.fn().mockResolvedValue(undefined);
+    webusb.receiveProtocolV2Frame = jest.fn(() => new Promise<void>(() => {}));
+    webusb.resetConnectionAfterProbe = jest.fn().mockImplementation(() => {
+      webusb.protocolV2Sessions.delete(path);
+      webusb.protocolV2ReadTimeouts.delete(path);
+      webusb.protocolV2Assemblers.get(path)?.reset();
+    });
+
+    await expect(
+      webusb.callProtocolV2(path, 'Ping', { message: 'timeout' }, { timeoutMs: 10 })
+    ).rejects.toThrow('timeout');
+
+    expect(webusb.resetConnectionAfterProbe).toHaveBeenCalledWith(path);
+    expect(webusb.protocolV2Sessions.has(path)).toBe(false);
+  });
+});

package/dist/electron-ble-transport.d.ts

@@ -28,8 +28,7 @@ export default class ElectronBleTransport {
     private v2Assemblers;
     private v2FrameQueues;
     private v2FramePromises;
-    private activeProtocolV2Call;
-    private nextProtocolV2CallToken;
+    private protocolV2Links;
     private notificationCleanups;
     private disconnectCleanups;
     private notificationTokens;
@@ -62,19 +61,20 @@ export default class ElectronBleTransport {
     private probeProtocolV1;
     private probeProtocolV2;
     private writeWithChunking;
-    private writeWithRetry;
+    private writeOnce;
     private handleNotification;
     private handleProtocolV2Notification;
     private getProtocolV2FrameQueue;
     private resolveProtocolV2Frame;
     private rejectAllProtocolV2Frames;
     private resetProtocolV2Frames;
-    private isActiveProtocolV2Call;
+    private rejectProtocolV2Frames;
     private readProtocolV2Frame;
     private handleProtocolV1Notification;
     call(uuid: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<import("@onekeyfe/hd-transport").MessageFromOneKey>;
     private callProtocolV1;
     private callProtocolV2;
+    private createProtocolV2Adapter;
     private processProtocolV1Notification;
     getProtocolType(path: string): ProtocolType | undefined;
 }

package/dist/electron-ble-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"electron-ble-transport.d.ts","sourceRoot":"","sources":["../src/electron-ble-transport.ts"],"names":[],"mappings":";AAmBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnG,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AAevC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,UAAU,CAAC,EAAE,UAAU,CAAC;KACzB;CACF;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;CACjC,CAAC;AAuCF,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,OAAO,CAAC,SAAS,CAA0D;IAE3E,OAAO,CAAC,WAAW,CAA0D;IAE7E,IAAI,SAA0B;IAE9B,UAAU,UAAS;IAEnB,UAAU,EAAE,QAAQ,CAAC,UAAU,GAAG,MAAM,CAAC,GAAG,IAAI,CAAQ;IAExD,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAEvB,OAAO,CAAC,gBAAgB,CAA0B;IAElD,OAAO,CAAC,cAAc,CAAwC;IAE9D,OAAO,CAAC,mBAAmB,CAAwC;IAEnE,OAAO,CAAC,SAAS,CAAsE;IAEvF,OAAO,CAAC,YAAY,CAAoD;IAExE,OAAO,CAAC,aAAa,CAAwC;IAE7D,OAAO,CAAC,eAAe,CAAgD;IAEvE,OAAO,CAAC,oBAAoB,CAAgD;IAE5E,OAAO,CAAC,uBAAuB,CAAK;IAEpC,OAAO,CAAC,oBAAoB,CAAsC;IAElE,OAAO,CAAC,kBAAkB,CAAsC;IAEhE,OAAO,CAAC,kBAAkB,CAAkC;IAE5D,OAAO,CAAC,qBAAqB,CAAK;IAElC,OAAO,CAAC,oBAAoB;IA+B5B,OAAO,CAAC,kBAAkB;IA0B1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAcxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAKzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAK7B,MAAM;IAIN,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAqBxC,OAAO,CAAC,KAAK,EAAE,eAAe;;;;;;;;;;;IAuF9B,OAAO,CAAC,EAAE,EAAE,MAAM;IAexB,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,kBAAkB;YAMZ,cAAc;IA+C5B,OAAO,CAAC,8BAA8B;YAgBxB,iCAAiC;YAoCjC,eAAe;YAgBf,eAAe;YAuBf,iBAAiB;YAsBjB,cAAc;IA4B5B,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,4BAA4B;IA2BpC,OAAO,CAAC,uBAAuB;IAS/B,OAAO,CAAC,sBAAsB;IAU9B,OAAO,CAAC,yBAAyB;IAQjC,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,sBAAsB;YAIhB,mBAAmB;IAiBjC,OAAO,CAAC,4BAA4B;IAgB9B,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YA+BlB,cAAc;YAuEd,cAAc;IAmF5B,OAAO,CAAC,6BAA6B;IAsCrC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}
+{"version":3,"file":"electron-ble-transport.d.ts","sourceRoot":"","sources":["../src/electron-ble-transport.ts"],"names":[],"mappings":";AAoBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnG,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AAIvC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,UAAU,CAAC,EAAE,UAAU,CAAC;KACzB;CACF;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;CACjC,CAAC;AAqCF,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,OAAO,CAAC,SAAS,CAA0D;IAE3E,OAAO,CAAC,WAAW,CAA0D;IAE7E,IAAI,SAA0B;IAE9B,UAAU,UAAS;IAEnB,UAAU,EAAE,QAAQ,CAAC,UAAU,GAAG,MAAM,CAAC,GAAG,IAAI,CAAQ;IAExD,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAEvB,OAAO,CAAC,gBAAgB,CAA0B;IAElD,OAAO,CAAC,cAAc,CAAwC;IAE9D,OAAO,CAAC,mBAAmB,CAAwC;IAEnE,OAAO,CAAC,SAAS,CAAsE;IAEvF,OAAO,CAAC,YAAY,CAAoD;IAExE,OAAO,CAAC,aAAa,CAAwC;IAE7D,OAAO,CAAC,eAAe,CAAgD;IAEvE,OAAO,CAAC,eAAe,CAmBpB;IAEH,OAAO,CAAC,oBAAoB,CAAsC;IAElE,OAAO,CAAC,kBAAkB,CAAsC;IAEhE,OAAO,CAAC,kBAAkB,CAAkC;IAE5D,OAAO,CAAC,qBAAqB,CAAK;IAElC,OAAO,CAAC,oBAAoB;IA+B5B,OAAO,CAAC,kBAAkB;IA0B1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAcxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAKzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAO7B,MAAM;IAIN,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAqBxC,OAAO,CAAC,KAAK,EAAE,eAAe;;;;;;;;;;;IA0F9B,OAAO,CAAC,EAAE,EAAE,MAAM;IAgBxB,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,kBAAkB;YAMZ,cAAc;IA8C5B,OAAO,CAAC,8BAA8B;YAgBxB,iCAAiC;YAqCjC,eAAe;YAgBf,eAAe;YAuBf,iBAAiB;YAsBjB,SAAS;IASvB,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,4BAA4B;IAkBpC,OAAO,CAAC,uBAAuB;IAS/B,OAAO,CAAC,sBAAsB;IAU9B,OAAO,CAAC,yBAAyB;IAQjC,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,sBAAsB;YAShB,mBAAmB;IAiBjC,OAAO,CAAC,4BAA4B;IAgB9B,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YA2BlB,cAAc;YAuEd,cAAc;IA6B5B,OAAO,CAAC,uBAAuB;IA0C/B,OAAO,CAAC,6BAA6B;IAsCrC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}

package/dist/index.d.ts

@@ -4,6 +4,9 @@ import { Deferred } from '@onekeyfe/hd-shared';
 import { DesktopAPI } from '@onekeyfe/hd-transport-electron';
 import EventEmitter from 'events';
 
+/**
+ * Device information with path and WebUSB device instance
+ */
 interface DeviceInfo extends OneKeyDeviceInfoBase {
     path: string;
     device: USBDevice;
@@ -11,13 +14,25 @@ interface DeviceInfo extends OneKeyDeviceInfoBase {
 }
 declare class WebUsbTransport {
     messages: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
+    /** Protobuf schema for Protocol V2 transports. */
     messagesV2: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
+    /** Per-path protocol type detected by active wire-level probe. */
     private deviceProtocol;
     private deviceProtocolHints;
+    /** Per-device Protocol V2 assembler that retains extra frames from one read. */
     private protocolV2Assemblers;
+    /** Per-device Protocol V2 session that keeps sequence numbers monotonic. */
     private protocolV2Sessions;
+    /** Sequence cursors survive ordinary reconnects and cached session rebuilds. */
+    private protocolV2Sequences;
+    /** Read timeout for the current Protocol V2 call, consumed by cached readFrame. */
     private protocolV2ReadTimeouts;
+    /** Per-path USB endpoint / interface numbers (discovered from USB descriptors) */
     private deviceEndpoints;
+    /**
+     * Early Pro2 boards have no USB serial number. Assign a session-stable mock path per
+     * USBDevice instance so discovery retains them; reconnecting creates a new instance/path.
+     */
     private mockSerialPaths;
     private mockSerialCounter;
     name: string;
@@ -25,24 +40,75 @@ declare class WebUsbTransport {
     configured: boolean;
     Log?: any;
     usb?: USB;
+    /**
+     * Cached list of connected devices
+     * This is essential for maintaining device references between operations
+     */
     deviceList: Array<DeviceInfo>;
     configurationId: number;
     endpointId: number;
     interfaceId: number;
+    /**
+     * Initialize WebUSB transport
+     */
     init(logger: any): void;
+    /**
+     * Configure Protocol V1 protobuf schema (legacy chunked 0x3F framing).
+     */
     configure(signedData: any): void;
+    /**
+     * Cache the Protocol V2 protobuf schema.
+     */
     configureProtocolV2(signedData: any): void;
+    /**
+     * Request user to select a device
+     * This method must be called in response to a user action
+     * to comply with WebUSB security requirements
+     */
     promptDeviceAccess(): Promise<USBDevice | null>;
+    /**
+     * Enumerate already connected devices
+     * This method only returns devices that are already authorized by the browser
+     * It does NOT prompt the user to select a device
+     */
     enumerate(): Promise<DeviceInfo[]>;
+    /**
+     * Use the USB serial as the device path, falling back to a session-stable mock path.
+     */
     private getDevicePath;
+    /**
+     * Get list of connected devices
+     */
     getConnectedDevices(): Promise<DeviceInfo[]>;
+    /**
+     * Acquire device control
+     */
     acquire(input: AcquireInput): Promise<string | undefined>;
+    /**
+     * Determine protocol type after connect.
+     * Probe Protocol V1 first with Initialize. If it does not answer in time,
+     * fall back to a Protocol V2 Ping probe.
+     */
     private createProtocolMismatchError;
     private createProtocolDetectionError;
     private detectProtocol;
+    /**
+     * Find device by path
+     */
     findDevice(path: string): Promise<USBDevice>;
+    /**
+     * Connect to device with retry mechanism
+     */
     connect(path: string, first: boolean): Promise<void>;
+    /**
+     * Discover vendor-class (0xFF) interface and its IN/OUT endpoint numbers from USB descriptors.
+     * Falls back to legacy hardcoded values if no vendor interface is found.
+     */
     private discoverEndpoints;
+    /**
+     * Connect to specific device.
+     * Discovers interface/endpoint numbers from USB descriptors on first connection.
+     */
     connectToDevice(path: string, first: boolean): Promise<void>;
     private closeOpenDevice;
     private clearEndpointHalt;
@@ -53,17 +119,37 @@ declare class WebUsbTransport {
     private getTransferInData;
     private toArrayBuffer;
     private transferOutWithRetry;
+    private transferOutOnce;
     private transferInWithRetry;
     private resetConnectionAfterProbe;
     private withProtocolReadTimeout;
     private probeProtocolV1;
     private probeProtocolV2;
+    /**
+     * Call device method — branches to Protocol V1 or Protocol V2 based on active probe.
+     */
     call(path: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<_onekeyfe_hd_transport.MessageFromOneKey>;
     private callProtocolV1;
+    /**
+     * Send/receive a single call over Protocol V2 (0x5A framing).
+     *
+     * Encoding:  protobuf message → 2-byte LE messageTypeId + pb bytes → Protocol V2 frame
+     * Decoding:  Protocol V2 frame → messageTypeId + pb bytes → protobuf message
+     */
     private callProtocolV2;
     private receiveProtocolV2Frame;
+    /**
+     * Receive data from device
+     */
     receiveData(path: string, timeoutMs?: number): Promise<string>;
+    /**
+     * Release device
+     */
     release(path: string): Promise<void>;
+    /**
+     * Expose the detected protocol type for a given device path.
+     * Used by upper layers (e.g. TransportManager) to select the correct schema.
+     */
     getProtocolType(path: string): ProtocolType | undefined;
 }
 
@@ -77,6 +163,12 @@ type BleAcquireInput = {
     forceCleanRunPromise?: boolean;
     expectedProtocol?: ProtocolType;
 };
+/**
+ * Desktop Electron BLE transport with automatic Protocol V1/V2 detection.
+ *
+ * Protocol V1 devices continue using chunked packets. Protocol V2 is detected
+ * after a Protocol V1 Initialize timeout by probing Protocol V2 Ping.
+ */
 declare class ElectronBleTransport {
     private _messages;
     private _messagesV2;
@@ -92,8 +184,7 @@ declare class ElectronBleTransport {
     private v2Assemblers;
     private v2FrameQueues;
     private v2FramePromises;
-    private activeProtocolV2Call;
-    private nextProtocolV2CallToken;
+    private protocolV2Links;
     private notificationCleanups;
     private disconnectCleanups;
     private notificationTokens;
@@ -126,19 +217,20 @@ declare class ElectronBleTransport {
     private probeProtocolV1;
     private probeProtocolV2;
     private writeWithChunking;
-    private writeWithRetry;
+    private writeOnce;
     private handleNotification;
     private handleProtocolV2Notification;
     private getProtocolV2FrameQueue;
     private resolveProtocolV2Frame;
     private rejectAllProtocolV2Frames;
     private resetProtocolV2Frames;
-    private isActiveProtocolV2Call;
+    private rejectProtocolV2Frames;
     private readProtocolV2Frame;
     private handleProtocolV1Notification;
     call(uuid: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<_onekeyfe_hd_transport.MessageFromOneKey>;
     private callProtocolV1;
     private callProtocolV2;
+    private createProtocolV2Adapter;
     private processProtocolV1Notification;
     getProtocolType(path: string): ProtocolType | undefined;
 }