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

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

@@ -1,5 +1,6 @@
 import transport, { PROTOCOL_V2_CHANNEL_BLE_UART, bytesToHex } from '@onekeyfe/hd-transport';
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import EventEmitter from 'events';
 
 import ElectronBleTransport from '../src/electron-ble-transport';
 
@@ -111,7 +112,10 @@ const createNobleBle = (device = { id: 'flaky-pro2-id', name: 'Unknown BLE Devic
   ),
 });
 
-const configureTransport = (nobleBle: ReturnType<typeof createNobleBle>) => {
+const configureTransport = (
+  nobleBle: ReturnType<typeof createNobleBle>,
+  emitter?: EventEmitter
+) => {
   (global as any).window = {
     desktopApi: {
       nobleBle,
@@ -119,7 +123,7 @@ const configureTransport = (nobleBle: ReturnType<typeof createNobleBle>) => {
   };
 
   const transport = new ElectronBleTransport();
-  transport.init(createLogger());
+  transport.init(createLogger(), emitter);
   transport.configure(protocolV1Schema);
   transport.configureProtocolV2(protocolV2Schema);
   return transport;
@@ -131,6 +135,54 @@ describe('ElectronBleTransport protocol detection', () => {
     jest.clearAllMocks();
   });
 
+  test('keeps raw BLE lifecycle payloads off the public device event channel', async () => {
+    const device = { id: 'lifecycle-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const emitter = new EventEmitter();
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    let disconnectHandler: ((device: { id: string; name: string | null }) => void) | undefined;
+    let responseSeq = 0;
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.onDeviceDisconnected.mockImplementation(handler => {
+      disconnectHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      responseSeq += 1;
+      const response = ProtocolV2.encodeFrame(
+        schemas,
+        'Success',
+        { message: 'ok' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: responseSeq }
+      );
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
+      return Promise.resolve();
+    });
+
+    const publicConnect = jest.fn();
+    const publicDisconnect = jest.fn();
+    const transportDisconnect = jest.fn();
+    emitter.on('device-connect', publicConnect);
+    emitter.on('device-disconnect', publicDisconnect);
+    emitter.on('transport-device-disconnect', transportDisconnect);
+    const bleTransport = configureTransport(nobleBle, emitter);
+
+    await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+    disconnectHandler?.(device);
+
+    expect(publicConnect).not.toHaveBeenCalled();
+    expect(publicDisconnect).not.toHaveBeenCalled();
+    expect(transportDisconnect).toHaveBeenCalledWith({
+      id: device.id,
+      connectId: device.id,
+      name: device.name,
+    });
+  });
+
   test('detects Protocol V2 after Protocol V1 probe timeout', async () => {
     const device = { id: 'unknown-pro2-id', name: 'Unknown BLE Device' };
     const nobleBle = createNobleBle(device);
@@ -341,4 +393,52 @@ describe('ElectronBleTransport protocol detection', () => {
       await transport.release(device.id);
     }
   });
+
+  test('preserves the active Protocol V2 link when the same schema is configured again', async () => {
+    const device = { id: 'stable-schema-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    let responseSeq = 0;
+    nobleBle.write.mockImplementation(() => {
+      responseSeq += 1;
+      const response = ProtocolV2.encodeFrame(
+        schemas,
+        'Success',
+        { message: 'ok' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: responseSeq }
+      );
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
+      return Promise.resolve();
+    });
+    const bleTransport = configureTransport(nobleBle);
+
+    try {
+      await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+      const invalidateAllLinks = jest.spyOn(
+        (bleTransport as any).protocolV2Links,
+        'invalidateAllLinks'
+      );
+      bleTransport.configureProtocolV2(protocolV2Schema);
+      await new Promise<void>(resolve => {
+        setTimeout(resolve, 0);
+      });
+      expect(invalidateAllLinks).not.toHaveBeenCalled();
+      await expect(
+        bleTransport.call(device.id, 'Ping', { message: 'same-schema' })
+      ).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 bleTransport.release(device.id);
+    }
+  });
 });

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

@@ -1,6 +1,6 @@
 import transport, {
+  PROTOCOL_V2_CHANNEL_USB,
   ProtocolV2,
-  ProtocolV2FrameAssembler,
   ProtocolV2LinkError,
 } from '@onekeyfe/hd-transport';
 
@@ -80,20 +80,72 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
     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.protocolV2Assemblers.get(path)?.reset();
-    });
+    webusb.writeProtocolV2UsbPacket = jest.fn().mockResolvedValue(undefined);
+    webusb.readProtocolV2UsbPacket = jest.fn(() => new Promise<void>(() => {}));
+    webusb.resetProtocolV2UsbNativeLink = jest.fn().mockResolvedValue(undefined);
+    webusb.resetConnectionAfterProbe = jest.fn();
+    await webusb.rotateProtocolV2UsbGeneration(path, 'test connection');
 
     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);
+    expect(webusb.resetProtocolV2UsbNativeLink).toHaveBeenCalledWith(
+      path,
+      expect.stringContaining('timeout')
+    );
+    expect(webusb.resetConnectionAfterProbe).not.toHaveBeenCalled();
+  });
+
+  test('does not reconnect inside a Protocol V2 frame read after a USB I/O failure', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro2-webusb';
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    webusb.writeProtocolV2UsbPacket = jest.fn().mockResolvedValue(undefined);
+    webusb.readProtocolV2UsbPacket = jest
+      .fn()
+      .mockRejectedValue(new Error('NetworkError: transferIn device disconnected'));
+    webusb.resetProtocolV2UsbNativeLink = jest.fn().mockResolvedValue(undefined);
+    webusb.resetConnectionAfterProbe = jest.fn();
+    await webusb.rotateProtocolV2UsbGeneration(path, 'test connection');
+
+    await expect(webusb.callProtocolV2(path, 'Ping', { message: 'read-error' })).rejects.toThrow(
+      'NetworkError'
+    );
+
+    expect(webusb.readProtocolV2UsbPacket).toHaveBeenCalledTimes(1);
+    expect(webusb.resetProtocolV2UsbNativeLink).toHaveBeenCalledWith(
+      path,
+      expect.stringContaining('NetworkError')
+    );
+    expect(webusb.resetConnectionAfterProbe).not.toHaveBeenCalled();
+  });
+
+  test('rejects an active Protocol V2 read without reconnecting after release', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro2-webusb';
+    let markReadStarted: () => void = () => undefined;
+    const readStarted = new Promise<void>(resolve => {
+      markReadStarted = resolve;
+    });
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    webusb.writeProtocolV2UsbPacket = jest.fn().mockResolvedValue(undefined);
+    webusb.readProtocolV2UsbPacket = jest.fn().mockImplementation(() => {
+      markReadStarted();
+      return new Promise<void>(() => {});
+    });
+    webusb.closeOpenDevice = jest.fn().mockResolvedValue(undefined);
+    webusb.connect = jest.fn();
+    await webusb.rotateProtocolV2UsbGeneration(path, 'test connection');
+
+    const call = webusb.callProtocolV2(path, 'Ping', { message: 'release' });
+    await readStarted;
+    await webusb.release(path);
+
+    await expect(call).rejects.toThrow('WebUSB transport released');
+    expect(webusb.connect).not.toHaveBeenCalled();
   });
 
   test.each(['router', 'packet-source', 'ack-sequence', 'response-sequence', 'frame'] as const)(
@@ -103,32 +155,34 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
       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.writeProtocolV2UsbPacket = jest.fn().mockResolvedValue(undefined);
       const recoveredResponse = ProtocolV2.encodeFrame(
         { protocolV1: webusb.messages, protocolV2: webusb.messagesV2 },
         'Success',
         { message: 'recovered' },
         { seq: 1 }
       );
-      webusb.receiveProtocolV2Frame = jest
+      webusb.readProtocolV2UsbPacket = jest
         .fn()
         .mockRejectedValueOnce(
           new ProtocolV2LinkError(code, `Protocol V2 ${code} validation failed`)
         )
         .mockResolvedValue(recoveredResponse);
-      webusb.resetConnectionAfterProbe = jest.fn().mockImplementation(() => {
-        webusb.protocolV2Sessions.delete(path);
-        webusb.protocolV2Assemblers.get(path)?.reset();
-      });
+      webusb.resetProtocolV2UsbNativeLink = jest.fn().mockResolvedValue(undefined);
+      webusb.resetConnectionAfterProbe = jest.fn();
+      await webusb.rotateProtocolV2UsbGeneration(path, 'test connection');
 
       await expect(webusb.callProtocolV2(path, 'Ping', { message: 'mismatch' })).rejects.toThrow(
         `${code} validation failed`
       );
 
-      expect(webusb.resetConnectionAfterProbe).toHaveBeenCalledWith(path);
-      expect(webusb.protocolV2Sessions.has(path)).toBe(false);
+      expect(webusb.resetProtocolV2UsbNativeLink).toHaveBeenCalledWith(
+        path,
+        expect.stringContaining(`${code} validation failed`)
+      );
+      expect(webusb.resetConnectionAfterProbe).not.toHaveBeenCalled();
 
+      await webusb.rotateProtocolV2UsbGeneration(path, 'test reconnect');
       await expect(
         webusb.callProtocolV2(path, 'Ping', { message: 'after-reset' })
       ).resolves.toMatchObject({
@@ -141,39 +195,53 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
   test('does not discard buffered Protocol V2 frames before each call', async () => {
     const webusb = new WebUsbTransport() as any;
     const path = 'pro2-webusb';
-    const assembler = new ProtocolV2FrameAssembler();
-    const reset = jest.spyOn(assembler, 'reset');
-    let responseSequence = 0;
     webusb.messages = transport.parseConfigure(schema);
     webusb.messagesV2 = transport.parseConfigure(schema);
-    webusb.protocolV2Assemblers.set(path, assembler);
-    webusb.transferOutOnce = jest.fn().mockResolvedValue(undefined);
-    webusb.receiveProtocolV2Frame = jest.fn().mockImplementation(() => {
-      responseSequence += 1;
-      const response = ProtocolV2.encodeFrame(
-        { protocolV1: webusb.messages, protocolV2: webusb.messagesV2 },
-        'Success',
-        { message: 'ok' },
-        { seq: responseSequence }
-      );
-      return Promise.resolve(response);
-    });
+    webusb.writeProtocolV2UsbPacket = jest.fn().mockResolvedValue(undefined);
+    const firstResponse = ProtocolV2.encodeFrame(
+      { protocolV1: webusb.messages, protocolV2: webusb.messagesV2 },
+      'Success',
+      { message: 'first' },
+      { router: PROTOCOL_V2_CHANNEL_USB, seq: 1 }
+    );
+    const secondResponse = ProtocolV2.encodeFrame(
+      { protocolV1: webusb.messages, protocolV2: webusb.messagesV2 },
+      'Success',
+      { message: 'second' },
+      { router: PROTOCOL_V2_CHANNEL_USB, seq: 2 }
+    );
+    const coalescedResponses = new Uint8Array(firstResponse.length + secondResponse.length);
+    coalescedResponses.set(firstResponse);
+    coalescedResponses.set(secondResponse, firstResponse.length);
+    webusb.readProtocolV2UsbPacket = jest.fn().mockResolvedValue(coalescedResponses);
+    webusb.resetProtocolV2UsbNativeLink = jest.fn().mockResolvedValue(undefined);
+    await webusb.rotateProtocolV2UsbGeneration(path, 'test connection');
 
-    await webusb.callProtocolV2(path, 'Ping', { message: 'first' });
-    await webusb.callProtocolV2(path, 'Ping', { message: 'second' });
+    await expect(webusb.callProtocolV2(path, 'Ping', { message: 'first' })).resolves.toMatchObject({
+      type: 'Success',
+      message: { message: 'first' },
+    });
+    await expect(webusb.callProtocolV2(path, 'Ping', { message: 'second' })).resolves.toMatchObject(
+      {
+        type: 'Success',
+        message: { message: 'second' },
+      }
+    );
 
-    expect(reset).not.toHaveBeenCalled();
+    expect(webusb.readProtocolV2UsbPacket).toHaveBeenCalledTimes(1);
   });
 
   test('keeps queued Protocol V2 read timeouts scoped to each call', async () => {
     const webusb = new WebUsbTransport() as any;
     const path = 'pro2-webusb';
     let responseSequence = 0;
+    const readTimeouts: number[] = [];
     webusb.messages = transport.parseConfigure(schema);
     webusb.messagesV2 = transport.parseConfigure(schema);
-    webusb.transferOutOnce = jest.fn().mockResolvedValue(undefined);
-    webusb.receiveProtocolV2Frame = jest.fn().mockImplementation(() => {
+    webusb.writeProtocolV2UsbPacket = jest.fn().mockResolvedValue(undefined);
+    webusb.readProtocolV2UsbPacket = jest.fn().mockImplementation((_path, context) => {
       responseSequence += 1;
+      readTimeouts.push(context.timeoutMs);
       return Promise.resolve(
         ProtocolV2.encodeFrame(
           { protocolV1: webusb.messages, protocolV2: webusb.messagesV2 },
@@ -183,14 +251,14 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
         )
       );
     });
+    webusb.resetProtocolV2UsbNativeLink = jest.fn().mockResolvedValue(undefined);
+    await webusb.rotateProtocolV2UsbGeneration(path, 'test connection');
 
     await Promise.all([
       webusb.callProtocolV2(path, 'Ping', { message: 'long' }, { timeoutMs: 1_000 }),
       webusb.callProtocolV2(path, 'Ping', { message: 'short' }, { timeoutMs: 25 }),
     ]);
 
-    expect(
-      webusb.receiveProtocolV2Frame.mock.calls.map(([, timeoutMs]: unknown[]) => timeoutMs)
-    ).toEqual([1_000, 25]);
+    expect(readTimeouts).toEqual([1_000, 25]);
   });
 });

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

@@ -16,6 +16,7 @@ export type BleAcquireInput = {
 export default class ElectronBleTransport {
     private _messages;
     private _messagesV2;
+    private protocolV2SchemaConfiguration;
     name: string;
     configured: boolean;
     runPromise: Deferred<Uint8Array | string> | null;

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":";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;AAoCF,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;IA+C5B,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;IA0B5B,OAAO,CAAC,uBAAuB;IA0C/B,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":";AAqBA,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;AAoCF,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,OAAO,CAAC,SAAS,CAA0D;IAE3E,OAAO,CAAC,WAAW,CAA0D;IAE7E,OAAO,CAAC,6BAA6B,CAAqB;IAE1D,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;IAgB7B,MAAM;IAIN,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAqBxC,OAAO,CAAC,KAAK,EAAE,eAAe;;;;;;;;;;;IAoF9B,OAAO,CAAC,EAAE,EAAE,MAAM;IAgBxB,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,kBAAkB;YAMZ,cAAc;IA+C5B,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;IA0B5B,OAAO,CAAC,uBAAuB;IA0C/B,OAAO,CAAC,6BAA6B;IAsCrC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _onekeyfe_hd_transport from '@onekeyfe/hd-transport';
-import _onekeyfe_hd_transport__default, { AcquireInput, TransportCallOptions, ProtocolType, OneKeyDeviceInfoBase, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
+import _onekeyfe_hd_transport__default, { ProtocolV2UsbTransportBase, AcquireInput, TransportCallOptions, ProtocolV2Schemas, ProtocolV2CallContext, ProtocolType, OneKeyDeviceInfoBase, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 import { Deferred } from '@onekeyfe/hd-shared';
 import { DesktopAPI } from '@onekeyfe/hd-transport-electron';
 import EventEmitter from 'events';
@@ -12,19 +12,13 @@ interface DeviceInfo extends OneKeyDeviceInfoBase {
     device: USBDevice;
     protocolType?: ProtocolType;
 }
-declare class WebUsbTransport {
+declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     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;
     /** Per-path USB endpoint / interface numbers (discovered from USB descriptors) */
     private deviceEndpoints;
     /**
@@ -46,6 +40,7 @@ declare class WebUsbTransport {
     configurationId: number;
     endpointId: number;
     interfaceId: number;
+    constructor();
     /**
      * Initialize WebUSB transport
      */
@@ -120,6 +115,7 @@ declare class WebUsbTransport {
     private transferOutWithRetry;
     private transferOutOnce;
     private transferInWithRetry;
+    private transferInOnce;
     private resetConnectionAfterProbe;
     private withProtocolReadTimeout;
     private probeProtocolV1;
@@ -136,7 +132,6 @@ declare class WebUsbTransport {
      * Decoding:  Protocol V2 frame → messageTypeId + pb bytes → protobuf message
      */
     private callProtocolV2;
-    private receiveProtocolV2Frame;
     /**
      * Receive data from device
      */
@@ -145,6 +140,13 @@ declare class WebUsbTransport {
      * Release device
      */
     release(path: string): Promise<void>;
+    protected getProtocolV2UsbSchemas(): ProtocolV2Schemas;
+    protected getProtocolV2UsbLogger(): any;
+    protected writeProtocolV2UsbPacket(path: string, frame: Uint8Array, _context: ProtocolV2CallContext): Promise<void>;
+    protected readProtocolV2UsbPacket(path: string, _context: ProtocolV2CallContext): Promise<Uint8Array>;
+    protected resetProtocolV2UsbNativeLink(path: string, _reason: string): Promise<void>;
+    protected onProtocolV2UsbLinkInvalidated(path: string, reason: string): void;
+    protected createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error;
     /**
      * Expose the detected protocol type for a given device path.
      * Used by upper layers (e.g. TransportManager) to select the correct schema.
@@ -171,6 +173,7 @@ type BleAcquireInput = {
 declare class ElectronBleTransport {
     private _messages;
     private _messagesV2;
+    private protocolV2SchemaConfiguration;
     name: string;
     configured: boolean;
     runPromise: Deferred<Uint8Array | string> | null;

package/dist/index.js

@@ -64,13 +64,15 @@ const EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS = 2;
 function inferProtocolHintFromDeviceName$1(name) {
     return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
 }
-class WebUsbTransport {
+class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     constructor() {
+        super({
+            router: transport.PROTOCOL_V2_CHANNEL_USB,
+            maxFrameBytes: transport.PROTOCOL_V2_FRAME_MAX_BYTES,
+            logPrefix: 'ProtocolV2 WebUSB',
+        });
         this.deviceProtocol = new Map();
         this.deviceProtocolHints = new Map();
-        this.protocolV2Assemblers = new Map();
-        this.protocolV2Sessions = new Map();
-        this.protocolV2Sequences = new Map();
         this.deviceEndpoints = new Map();
         this.mockSerialPaths = new WeakMap();
         this.mockSerialCounter = 0;
@@ -97,7 +99,7 @@ class WebUsbTransport {
     }
     configureProtocolV2(signedData) {
         this.messagesV2 = parseConfigure$1(signedData);
-        this.protocolV2Sessions.clear();
+        this.invalidateAllProtocolV2UsbLinks('Protocol V2 schema reconfigured').catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] schema link cleanup failed:', error); });
     }
     promptDeviceAccess() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -163,6 +165,7 @@ class WebUsbTransport {
             if (!input.path)
                 return;
             try {
+                yield this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
                 yield this.closeOpenDevice(input.path);
                 yield this.connect((_a = input.path) !== null && _a !== void 0 ? _a : '', true);
                 const deviceName = (_b = this.deviceList.find(device => device.path === input.path)) === null || _b === void 0 ? void 0 : _b.device.productName;
@@ -289,7 +292,7 @@ class WebUsbTransport {
         };
     }
     connectToDevice(path, first) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let device = yield this.findDevice(path);
             if (!device.opened) {
@@ -313,33 +316,30 @@ class WebUsbTransport {
             }
             const endpoints = this.discoverEndpoints(device);
             this.deviceEndpoints.set(path, endpoints);
-            (_b = this.protocolV2Assemblers.get(path)) === null || _b === void 0 ? void 0 : _b.reset();
-            this.protocolV2Assemblers.set(path, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES));
             yield device.claimInterface(endpoints.interfaceNumber);
             yield this.clearEndpointHalt(device, 'in', endpoints.endpointIn);
             yield this.clearEndpointHalt(device, 'out', endpoints.endpointOut);
         });
     }
     closeOpenDevice(path) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
-            const current = (_b = this.deviceList.find(device => device.path === path)) === null || _b === void 0 ? void 0 : _b.device;
+            const current = (_a = this.deviceList.find(device => device.path === path)) === null || _a === void 0 ? void 0 : _a.device;
             if (!(current === null || current === void 0 ? void 0 : current.opened))
                 return;
             const endpoints = this.deviceEndpoints.get(path);
-            const ifaceNum = (_c = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _c !== void 0 ? _c : this.interfaceId;
+            const ifaceNum = (_b = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _b !== void 0 ? _b : this.interfaceId;
             try {
                 yield current.releaseInterface(ifaceNum);
             }
             catch (error) {
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
             }
             try {
                 yield current.close();
             }
             catch (error) {
-                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug('[WebUsbTransport] close before reconnect failed:', error);
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] close before reconnect failed:', error);
             }
         });
     }
@@ -501,16 +501,28 @@ class WebUsbTransport {
             throw lastError;
         });
     }
+    transferInOnce(path, length) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.findDevice(path);
+            if (!device.opened) {
+                throw new Error('USBDevice is not open for transferIn');
+            }
+            const endpoints = this.deviceEndpoints.get(path);
+            const endpointIn = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointIn) !== null && _a !== void 0 ? _a : this.endpointId;
+            const result = yield device.transferIn(endpointIn, length);
+            return this.getTransferInData(result);
+        });
+    }
     resetConnectionAfterProbe(path) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
-            this.protocolV2Sessions.delete(path);
+            yield this.rotateProtocolV2UsbGeneration(path, 'WebUSB protocol probe reset');
             try {
                 const device = yield this.findDevice(path);
                 if (device.opened) {
                     const endpoints = this.deviceEndpoints.get(path);
-                    const ifaceNum = (_b = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _b !== void 0 ? _b : this.interfaceId;
+                    const ifaceNum = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _a !== void 0 ? _a : this.interfaceId;
                     try {
                         yield device.releaseInterface(ifaceNum);
                     }
@@ -584,7 +596,7 @@ class WebUsbTransport {
                 return false;
             }
             return transport.probeProtocolV2({
-                call: (name, data, options) => this.callProtocolV2(path, name, data, options, false),
+                call: (name, data, options) => this.callProtocolV2(path, name, data, options),
                 timeoutMs: PROTOCOL_PROBE_TIMEOUT,
                 logger: this.Log,
                 logPrefix: 'ProtocolV2 WebUSB',
@@ -634,74 +646,9 @@ class WebUsbTransport {
             return check$1.call(jsonData);
         });
     }
-    callProtocolV2(path, name, data, options, resetOnError = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const protocolV1Messages = this.messages;
-            if (!this.messagesV2) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Protocol V2 schema not configured');
-            }
-            if (!protocolV1Messages) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
-            }
-            let session = this.protocolV2Sessions.get(path);
-            if (!session) {
-                let sequenceCursor = this.protocolV2Sequences.get(path);
-                if (!sequenceCursor) {
-                    sequenceCursor = new transport.ProtocolV2SequenceCursor();
-                    this.protocolV2Sequences.set(path, sequenceCursor);
-                }
-                session = new transport.ProtocolV2Session({
-                    schemas: {
-                        protocolV1: protocolV1Messages,
-                        protocolV2: this.messagesV2,
-                    },
-                    router: transport.PROTOCOL_V2_CHANNEL_USB,
-                    sequenceCursor,
-                    writeFrame: (frame) => this.transferOutOnce(path, frame),
-                    readFrame: context => this.receiveProtocolV2Frame(path, context.timeoutMs),
-                    logger: this.Log,
-                    logPrefix: 'ProtocolV2 WebUSB',
-                    createTimeoutError: (messageName, timeoutMs) => new transport.ProtocolV2LinkError('response-timeout', `Protocol V2 response timeout after ${timeoutMs}ms for ${messageName}`),
-                });
-                this.protocolV2Sessions.set(path, session);
-            }
-            try {
-                return yield session.call(name, data, options);
-            }
-            catch (error) {
-                if (resetOnError && (transport.isProtocolV2LinkError(error) || this.isRetryablePacketIoError(error))) {
-                    try {
-                        yield this.resetConnectionAfterProbe(path);
-                    }
-                    catch (resetError) {
-                        this.Log.debug('[WebUsbTransport] Protocol V2 link reset failed:', resetError);
-                    }
-                }
-                throw error;
-            }
-        });
-    }
-    receiveProtocolV2Frame(path, timeoutMs) {
+    callProtocolV2(path, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            let assembler = this.protocolV2Assemblers.get(path);
-            if (!assembler) {
-                assembler = new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES);
-                this.protocolV2Assemblers.set(path, assembler);
-            }
-            let frame = assembler.push(new Uint8Array(0));
-            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
-            while (!frame) {
-                const cancelToken = { cancelled: false };
-                const transferIn = this.transferInWithRetry(path, transport.PROTOCOL_V2_FRAME_MAX_BYTES, cancelToken);
-                const dataView = deadline
-                    ? yield this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V2', () => {
-                        cancelToken.cancelled = true;
-                    })
-                    : yield transferIn;
-                const bytes = new Uint8Array(this.toArrayBuffer(dataView.buffer.slice(dataView.byteOffset, dataView.byteOffset + dataView.byteLength)));
-                frame = assembler.push(bytes);
-            }
-            return frame;
+            return this.callProtocolV2Usb(path, name, data, options);
         });
     }
     receiveData(path, timeoutMs) {
@@ -742,21 +689,50 @@ class WebUsbTransport {
         });
     }
     release(path) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const device = yield this.findDevice(path);
-            const endpoints = this.deviceEndpoints.get(path);
-            const ifaceNum = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _a !== void 0 ? _a : this.interfaceId;
-            yield device.releaseInterface(ifaceNum);
-            yield device.close();
+            yield this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
+            yield this.closeOpenDevice(path);
             this.deviceProtocol.delete(path);
             this.deviceProtocolHints.delete(path);
-            (_b = this.protocolV2Assemblers.get(path)) === null || _b === void 0 ? void 0 : _b.reset();
-            this.protocolV2Assemblers.delete(path);
-            this.protocolV2Sessions.delete(path);
             this.deviceEndpoints.delete(path);
         });
     }
+    getProtocolV2UsbSchemas() {
+        if (!this.messages || !this.messagesV2) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+        }
+        return {
+            protocolV1: this.messages,
+            protocolV2: this.messagesV2,
+        };
+    }
+    getProtocolV2UsbLogger() {
+        return this.Log;
+    }
+    writeProtocolV2UsbPacket(path, frame, _context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transferOutOnce(path, frame);
+        });
+    }
+    readProtocolV2UsbPacket(path, _context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataView = yield this.transferInOnce(path, transport.PROTOCOL_V2_FRAME_MAX_BYTES);
+            return new Uint8Array(this.toArrayBuffer(dataView.buffer.slice(dataView.byteOffset, dataView.byteOffset + dataView.byteLength)));
+        });
+    }
+    resetProtocolV2UsbNativeLink(path, _reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.closeOpenDevice(path);
+        });
+    }
+    onProtocolV2UsbLinkInvalidated(path, reason) {
+        var _a;
+        this.deviceProtocol.delete(path);
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[WebUsbTransport] Protocol V2 link invalidated: ${path}`, reason);
+    }
+    createProtocolV2UsbTimeoutError(name, timeoutMs) {
+        return new transport.ProtocolV2LinkError('response-timeout', `Protocol V2 response timeout after ${timeoutMs}ms for ${name}`);
+    }
     getProtocolType(path) {
         return this.deviceProtocol.get(path);
     }
@@ -873,10 +849,18 @@ class ElectronBleTransport {
         this.configured = true;
     }
     configureProtocolV2(signedData) {
+        const configuration = typeof signedData === 'string' ? signedData : JSON.stringify(signedData);
+        if (this.protocolV2SchemaConfiguration === configuration) {
+            return;
+        }
+        const isReconfiguration = this.protocolV2SchemaConfiguration !== undefined;
         this._messagesV2 = parseConfigure(signedData);
-        this.protocolV2Links
-            .invalidateAllLinks('Protocol V2 schema reconfigured')
-            .catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] schema link cleanup failed:', error); });
+        this.protocolV2SchemaConfiguration = configuration;
+        if (isReconfiguration) {
+            this.protocolV2Links
+                .invalidateAllLinks('Protocol V2 schema reconfigured')
+                .catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] schema link cleanup failed:', error); });
+        }
     }
     listen() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -908,7 +892,7 @@ class ElectronBleTransport {
         });
     }
     acquire(input) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             const { uuid, forceCleanRunPromise, expectedProtocol } = input;
             if (!uuid) {
@@ -953,7 +937,7 @@ class ElectronBleTransport {
                     var _a;
                     if (disconnectedDevice.id === uuid) {
                         this.cleanupDeviceState(uuid);
-                        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit('device-disconnect', {
+                        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit(transport.TRANSPORT_EVENT.DEVICE_DISCONNECT, {
                             name: disconnectedDevice.name,
                             id: disconnectedDevice.id,
                             connectId: disconnectedDevice.id,
@@ -962,23 +946,18 @@ class ElectronBleTransport {
                 });
                 this.disconnectCleanups.set(uuid, disconnectCleanup);
                 const protocolType = yield this.detectProtocol(uuid, expectedProtocol, protocolHint);
-                (_c = this.emitter) === null || _c === void 0 ? void 0 : _c.emit('device-connect', {
-                    name: device.name,
-                    id: device.id,
-                    connectId: device.id,
-                });
                 return Object.assign(Object.assign({}, toBleDescriptor({ id: device.id, name: device.name }, protocolType)), { uuid });
             }
             catch (error) {
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Electron BLE] acquire failed:', error);
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.error('[Electron BLE] acquire failed:', error);
                 try {
-                    if (((_e = window.desktopApi) === null || _e === void 0 ? void 0 : _e.nobleBle) && this.connectedDevices.has(uuid)) {
+                    if (((_d = window.desktopApi) === null || _d === void 0 ? void 0 : _d.nobleBle) && this.connectedDevices.has(uuid)) {
                         yield window.desktopApi.nobleBle.unsubscribe(uuid);
                         yield window.desktopApi.nobleBle.disconnect(uuid);
                     }
                 }
                 catch (cleanupError) {
-                    (_f = this.Log) === null || _f === void 0 ? void 0 : _f.debug('[Electron BLE] acquire cleanup failed:', cleanupError);
+                    (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug('[Electron BLE] acquire cleanup failed:', cleanupError);
                 }
                 this.cleanupDeviceState(uuid);
                 throw error;

package/dist/webusb.d.ts

@@ -1,19 +1,16 @@
 /// <reference types="w3c-web-usb" />
-import transport from '@onekeyfe/hd-transport';
-import type { AcquireInput, OneKeyDeviceInfoBase, ProtocolType, TransportCallOptions } from '@onekeyfe/hd-transport';
+import transport, { ProtocolV2UsbTransportBase } from '@onekeyfe/hd-transport';
+import type { AcquireInput, OneKeyDeviceInfoBase, ProtocolType, ProtocolV2CallContext, ProtocolV2Schemas, TransportCallOptions } from '@onekeyfe/hd-transport';
 export interface DeviceInfo extends OneKeyDeviceInfoBase {
     path: string;
     device: USBDevice;
     protocolType?: ProtocolType;
 }
-export default class WebUsbTransport {
+export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     messages: ReturnType<typeof transport.parseConfigure> | undefined;
     messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
     private deviceProtocol;
     private deviceProtocolHints;
-    private protocolV2Assemblers;
-    private protocolV2Sessions;
-    private protocolV2Sequences;
     private deviceEndpoints;
     private mockSerialPaths;
     private mockSerialCounter;
@@ -26,6 +23,7 @@ export default class WebUsbTransport {
     configurationId: number;
     endpointId: number;
     interfaceId: number;
+    constructor();
     init(logger: any): void;
     configure(signedData: any): void;
     configureProtocolV2(signedData: any): void;
@@ -53,6 +51,7 @@ export default class WebUsbTransport {
     private transferOutWithRetry;
     private transferOutOnce;
     private transferInWithRetry;
+    private transferInOnce;
     private resetConnectionAfterProbe;
     private withProtocolReadTimeout;
     private probeProtocolV1;
@@ -60,9 +59,15 @@ export default class WebUsbTransport {
     call(path: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<import("@onekeyfe/hd-transport").MessageFromOneKey>;
     private callProtocolV1;
     private callProtocolV2;
-    private receiveProtocolV2Frame;
     receiveData(path: string, timeoutMs?: number): Promise<string>;
     release(path: string): Promise<void>;
+    protected getProtocolV2UsbSchemas(): ProtocolV2Schemas;
+    protected getProtocolV2UsbLogger(): any;
+    protected writeProtocolV2UsbPacket(path: string, frame: Uint8Array, _context: ProtocolV2CallContext): Promise<void>;
+    protected readProtocolV2UsbPacket(path: string, _context: ProtocolV2CallContext): Promise<Uint8Array>;
+    protected resetProtocolV2UsbNativeLink(path: string, _reason: string): Promise<void>;
+    protected onProtocolV2UsbLinkInvalidated(path: string, reason: string): void;
+    protected createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error;
     getProtocolType(path: string): ProtocolType | undefined;
 }
 //# sourceMappingURL=webusb.d.ts.map

package/dist/webusb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webusb.d.ts","sourceRoot":"","sources":["../src/webusb.ts"],"names":[],"mappings":";AACA,OAAO,SAaN,MAAM,wBAAwB,CAAC;AAYhC,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACpB,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAsBhC,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAaD,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAGlE,UAAU,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAGpE,OAAO,CAAC,cAAc,CAAwC;IAE9D,OAAO,CAAC,mBAAmB,CAAwC;IAGnE,OAAO,CAAC,oBAAoB,CAAoD;IAGhF,OAAO,CAAC,kBAAkB,CAA6C;IAGvE,OAAO,CAAC,mBAAmB,CAAoD;IAG/E,OAAO,CAAC,eAAe,CAA2C;IAMlE,OAAO,CAAC,eAAe,CAA6C;IAEpE,OAAO,CAAC,iBAAiB,CAAK;IAE9B,IAAI,SAAqB;IAEzB,OAAO,UAAS;IAEhB,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,GAAG,CAAC,EAAE,GAAG,CAAC;IAMV,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAM;IAEnC,eAAe,SAAoB;IAEnC,UAAU,SAAe;IAEzB,WAAW,SAAgB;IAK3B,IAAI,CAAC,MAAM,EAAE,GAAG;IAgBhB,SAAS,CAAC,UAAU,EAAE,GAAG;IASzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAU7B,kBAAkB;IAmBlB,SAAS;IAQf,OAAO,CAAC,aAAa;IAmBf,mBAAmB;IAgCnB,OAAO,CAAC,KAAK,EAAE,YAAY;IA0BjC,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,+BAA+B;IAOvC,OAAO,CAAC,4BAA4B;YAOtB,cAAc;IA6DtB,UAAU,CAAC,IAAI,EAAE,MAAM;IAwBvB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAkB1C,OAAO,CAAC,iBAAiB;IAiCnB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;YAmCpC,eAAe;YAmBf,iBAAiB;IAezB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIvE,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,wBAAwB;YAalB,yBAAyB;IAiCvC,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,aAAa;YASP,oBAAoB;YA2BpB,eAAe;YAaf,mBAAmB;YA2CnB,yBAAyB;YAwBzB,uBAAuB;YA0CvB,eAAe;YAaf,eAAe;IAgBvB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YA8BlB,cAAc;YAkCd,cAAc;YA2Dd,sBAAsB;IAqC9B,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;IAgD5C,OAAO,CAAC,IAAI,EAAE,MAAM;IAkB1B,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}
+{"version":3,"file":"webusb.d.ts","sourceRoot":"","sources":["../src/webusb.ts"],"names":[],"mappings":";AACA,OAAO,SAAS,EAAE,EAQhB,0BAA0B,EAE3B,MAAM,wBAAwB,CAAC;AAYhC,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACpB,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAsBhC,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAaD,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,0BAA0B,CAAC,MAAM,CAAC;IAC7E,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAGlE,UAAU,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAGpE,OAAO,CAAC,cAAc,CAAwC;IAE9D,OAAO,CAAC,mBAAmB,CAAwC;IAGnE,OAAO,CAAC,eAAe,CAA2C;IAMlE,OAAO,CAAC,eAAe,CAA6C;IAEpE,OAAO,CAAC,iBAAiB,CAAK;IAE9B,IAAI,SAAqB;IAEzB,OAAO,UAAS;IAEhB,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,GAAG,CAAC,EAAE,GAAG,CAAC;IAMV,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAM;IAEnC,eAAe,SAAoB;IAEnC,UAAU,SAAe;IAEzB,WAAW,SAAgB;;IAa3B,IAAI,CAAC,MAAM,EAAE,GAAG;IAgBhB,SAAS,CAAC,UAAU,EAAE,GAAG;IASzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAY7B,kBAAkB;IAmBlB,SAAS;IAQf,OAAO,CAAC,aAAa;IAmBf,mBAAmB;IAgCnB,OAAO,CAAC,KAAK,EAAE,YAAY;IA2BjC,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,+BAA+B;IAOvC,OAAO,CAAC,4BAA4B;YAOtB,cAAc;IA6DtB,UAAU,CAAC,IAAI,EAAE,MAAM;IAwBvB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAkB1C,OAAO,CAAC,iBAAiB;IAiCnB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;YAgCpC,eAAe;YAkBf,iBAAiB;IAezB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIvE,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,wBAAwB;YAalB,yBAAyB;IAiCvC,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,aAAa;YASP,oBAAoB;YA2BpB,eAAe;YAaf,mBAAmB;YA2CnB,cAAc;YAWd,yBAAyB;YAuBzB,uBAAuB;YA0CvB,eAAe;YAaf,eAAe;IAgBvB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YA8BlB,cAAc;YAkCd,cAAc;IAYtB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;IAgD5C,OAAO,CAAC,IAAI,EAAE,MAAM;IAQ1B,SAAS,CAAC,uBAAuB,IAAI,iBAAiB;IAUtD,SAAS,CAAC,sBAAsB;cAIhB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CAAC,IAAI,CAAC;cAIA,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CAAC,UAAU,CAAC;cASN,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1F,SAAS,CAAC,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAKrE,SAAS,CAAC,+BAA+B,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK;IAWjF,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-web-device",
-  "version": "1.2.0-alpha.23",
+  "version": "1.2.0-alpha.25",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -20,13 +20,13 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.23",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.23"
+    "@onekeyfe/hd-shared": "1.2.0-alpha.25",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.25"
   },
   "devDependencies": {
-    "@onekeyfe/hd-transport-electron": "1.2.0-alpha.23",
+    "@onekeyfe/hd-transport-electron": "1.2.0-alpha.25",
     "@types/w3c-web-usb": "^1.0.6",
     "@types/web-bluetooth": "^0.0.17"
   },
-  "gitHead": "7cadb40ca6414053a488756f28a9f413164b235d"
+  "gitHead": "20bb98b8530c509299b9e109d2b5ada7c6a6d034"
 }

package/src/electron-ble-transport.ts

@@ -3,6 +3,7 @@ import transport, {
   PROTOCOL_V2_CHANNEL_BLE_UART,
   ProtocolV2FrameAssembler,
   ProtocolV2LinkManager,
+  TRANSPORT_EVENT,
   bytesToHex,
   hexToBytes,
   probeProtocolV2 as probeProtocolV2Helper,
@@ -76,6 +77,8 @@ export default class ElectronBleTransport {
 
   private _messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
 
+  private protocolV2SchemaConfiguration: string | undefined;
+
   name = 'ElectronBleTransport';
 
   configured = false;
@@ -206,10 +209,19 @@ export default class ElectronBleTransport {
   }
 
   configureProtocolV2(signedData: any) {
+    const configuration = typeof signedData === 'string' ? signedData : JSON.stringify(signedData);
+    if (this.protocolV2SchemaConfiguration === configuration) {
+      return;
+    }
+
+    const isReconfiguration = this.protocolV2SchemaConfiguration !== undefined;
     this._messagesV2 = parseConfigure(signedData);
-    this.protocolV2Links
-      .invalidateAllLinks('Protocol V2 schema reconfigured')
-      .catch(error => this.Log?.debug('[Electron BLE] schema link cleanup failed:', error));
+    this.protocolV2SchemaConfiguration = configuration;
+    if (isReconfiguration) {
+      this.protocolV2Links
+        .invalidateAllLinks('Protocol V2 schema reconfigured')
+        .catch(error => this.Log?.debug('[Electron BLE] schema link cleanup failed:', error));
+    }
   }
 
   async listen() {
@@ -290,7 +302,7 @@ export default class ElectronBleTransport {
         (disconnectedDevice: any) => {
           if (disconnectedDevice.id === uuid) {
             this.cleanupDeviceState(uuid);
-            this.emitter?.emit('device-disconnect', {
+            this.emitter?.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, {
               name: disconnectedDevice.name,
               id: disconnectedDevice.id,
               connectId: disconnectedDevice.id,
@@ -302,12 +314,6 @@ export default class ElectronBleTransport {
 
       const protocolType = await this.detectProtocol(uuid, expectedProtocol, protocolHint);
 
-      this.emitter?.emit('device-connect', {
-        name: device.name,
-        id: device.id,
-        connectId: device.id,
-      });
-
       return {
         ...toBleDescriptor({ id: device.id, name: device.name }, protocolType),
         uuid,

package/src/webusb.ts

@@ -6,11 +6,8 @@ import transport, {
   PROTOCOL_V1_USB_PACKET_SIZE,
   PROTOCOL_V2_CHANNEL_USB,
   PROTOCOL_V2_FRAME_MAX_BYTES,
-  ProtocolV2FrameAssembler,
   ProtocolV2LinkError,
-  ProtocolV2SequenceCursor,
-  ProtocolV2Session,
-  isProtocolV2LinkError,
+  ProtocolV2UsbTransportBase,
   probeProtocolV2 as probeProtocolV2Helper,
 } from '@onekeyfe/hd-transport';
 import {
@@ -28,6 +25,8 @@ import type {
   AcquireInput,
   OneKeyDeviceInfoBase,
   ProtocolType,
+  ProtocolV2CallContext,
+  ProtocolV2Schemas,
   TransportCallOptions,
 } from '@onekeyfe/hd-transport';
 
@@ -68,7 +67,7 @@ interface TransferCancelToken {
   cancelled: boolean;
 }
 
-export default class WebUsbTransport {
+export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
   messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
   /** Protobuf schema for Protocol V2 transports. */
@@ -79,15 +78,6 @@ export default class WebUsbTransport {
 
   private deviceProtocolHints: Map<string, ProtocolType> = new Map();
 
-  /** Per-device Protocol V2 assembler that retains extra frames from one read. */
-  private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
-
-  /** Per-device Protocol V2 session that keeps sequence numbers monotonic. */
-  private protocolV2Sessions: Map<string, ProtocolV2Session> = new Map();
-
-  /** Sequence cursors survive ordinary reconnects and cached session rebuilds. */
-  private protocolV2Sequences: Map<string, ProtocolV2SequenceCursor> = new Map();
-
   /** Per-path USB endpoint / interface numbers (discovered from USB descriptors) */
   private deviceEndpoints: Map<string, DeviceEndpoints> = new Map();
 
@@ -121,6 +111,14 @@ export default class WebUsbTransport {
 
   interfaceId = INTERFACE_ID;
 
+  constructor() {
+    super({
+      router: PROTOCOL_V2_CHANNEL_USB,
+      maxFrameBytes: PROTOCOL_V2_FRAME_MAX_BYTES,
+      logPrefix: 'ProtocolV2 WebUSB',
+    });
+  }
+
   /**
    * Initialize WebUSB transport
    */
@@ -151,7 +149,9 @@ export default class WebUsbTransport {
    */
   configureProtocolV2(signedData: any) {
     this.messagesV2 = parseConfigure(signedData);
-    this.protocolV2Sessions.clear();
+    this.invalidateAllProtocolV2UsbLinks('Protocol V2 schema reconfigured').catch(error =>
+      this.Log?.debug('[WebUsbTransport] schema link cleanup failed:', error)
+    );
   }
 
   /**
@@ -240,6 +240,7 @@ export default class WebUsbTransport {
   async acquire(input: AcquireInput) {
     if (!input.path) return;
     try {
+      await this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
       await this.closeOpenDevice(input.path);
       await this.connect(input.path ?? '', true);
       const deviceName = this.deviceList.find(device => device.path === input.path)?.device
@@ -447,16 +448,12 @@ export default class WebUsbTransport {
     // Discover endpoints from USB descriptors; descriptors are not used for protocol selection.
     const endpoints = this.discoverEndpoints(device);
     this.deviceEndpoints.set(path, endpoints);
-    this.protocolV2Assemblers.get(path)?.reset();
-    this.protocolV2Assemblers.set(path, new ProtocolV2FrameAssembler(PROTOCOL_V2_FRAME_MAX_BYTES));
-
     await device.claimInterface(endpoints.interfaceNumber);
     await this.clearEndpointHalt(device, 'in', endpoints.endpointIn);
     await this.clearEndpointHalt(device, 'out', endpoints.endpointOut);
   }
 
   private async closeOpenDevice(path: string) {
-    this.protocolV2Assemblers.get(path)?.reset();
     const current = this.deviceList.find(device => device.path === path)?.device;
     if (!current?.opened) return;
 
@@ -651,9 +648,19 @@ export default class WebUsbTransport {
     throw lastError;
   }
 
+  private async transferInOnce(path: string, length: number): Promise<DataView> {
+    const device = await this.findDevice(path);
+    if (!device.opened) {
+      throw new Error('USBDevice is not open for transferIn');
+    }
+    const endpoints = this.deviceEndpoints.get(path);
+    const endpointIn = endpoints?.endpointIn ?? this.endpointId;
+    const result = await device.transferIn(endpointIn, length);
+    return this.getTransferInData(result);
+  }
+
   private async resetConnectionAfterProbe(path: string) {
-    this.protocolV2Assemblers.get(path)?.reset();
-    this.protocolV2Sessions.delete(path);
+    await this.rotateProtocolV2UsbGeneration(path, 'WebUSB protocol probe reset');
 
     try {
       const device = await this.findDevice(path);
@@ -736,7 +743,7 @@ export default class WebUsbTransport {
     }
 
     return probeProtocolV2Helper({
-      call: (name, data, options) => this.callProtocolV2(path, name, data, options, false),
+      call: (name, data, options) => this.callProtocolV2(path, name, data, options),
       timeoutMs: PROTOCOL_PROBE_TIMEOUT,
       logger: this.Log,
       logPrefix: 'ProtocolV2 WebUSB',
@@ -818,93 +825,9 @@ export default class WebUsbTransport {
     path: string,
     name: string,
     data: Record<string, unknown>,
-    options?: TransportCallOptions,
-    resetOnError = true
+    options?: TransportCallOptions
   ) {
-    const protocolV1Messages = this.messages;
-    if (!this.messagesV2) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.TransportNotConfigured,
-        'Protocol V2 schema not configured'
-      );
-    }
-    if (!protocolV1Messages) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
-    }
-
-    let session = this.protocolV2Sessions.get(path);
-    if (!session) {
-      let sequenceCursor = this.protocolV2Sequences.get(path);
-      if (!sequenceCursor) {
-        sequenceCursor = new ProtocolV2SequenceCursor();
-        this.protocolV2Sequences.set(path, sequenceCursor);
-      }
-      session = new ProtocolV2Session({
-        schemas: {
-          protocolV1: protocolV1Messages,
-          protocolV2: this.messagesV2,
-        },
-        router: PROTOCOL_V2_CHANNEL_USB,
-        sequenceCursor,
-        writeFrame: (frame: Uint8Array) => this.transferOutOnce(path, frame),
-        readFrame: context => this.receiveProtocolV2Frame(path, context.timeoutMs),
-        logger: this.Log,
-        logPrefix: 'ProtocolV2 WebUSB',
-        createTimeoutError: (messageName: string, timeoutMs: number) =>
-          new ProtocolV2LinkError(
-            'response-timeout',
-            `Protocol V2 response timeout after ${timeoutMs}ms for ${messageName}`
-          ),
-      });
-      this.protocolV2Sessions.set(path, session);
-    }
-
-    try {
-      return await session.call(name, data, options);
-    } catch (error) {
-      if (resetOnError && (isProtocolV2LinkError(error) || this.isRetryablePacketIoError(error))) {
-        try {
-          await this.resetConnectionAfterProbe(path);
-        } catch (resetError) {
-          this.Log.debug('[WebUsbTransport] Protocol V2 link reset failed:', resetError);
-        }
-      }
-      throw error;
-    }
-  }
-
-  private async receiveProtocolV2Frame(path: string, timeoutMs?: number): Promise<Uint8Array> {
-    let assembler = this.protocolV2Assemblers.get(path);
-    if (!assembler) {
-      assembler = new ProtocolV2FrameAssembler(PROTOCOL_V2_FRAME_MAX_BYTES);
-      this.protocolV2Assemblers.set(path, assembler);
-    }
-
-    let frame: Uint8Array | undefined = assembler.push(new Uint8Array(0));
-    const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
-
-    while (!frame) {
-      const cancelToken = { cancelled: false };
-      const transferIn = this.transferInWithRetry(path, PROTOCOL_V2_FRAME_MAX_BYTES, cancelToken);
-      const dataView = deadline
-        ? await this.withProtocolReadTimeout(
-            path,
-            transferIn,
-            Math.max(deadline - Date.now(), 1),
-            'V2',
-            () => {
-              cancelToken.cancelled = true;
-            }
-          )
-        : await transferIn;
-      const bytes = new Uint8Array(
-        this.toArrayBuffer(
-          dataView.buffer.slice(dataView.byteOffset, dataView.byteOffset + dataView.byteLength)
-        )
-      );
-      frame = assembler.push(bytes);
-    }
-    return frame;
+    return this.callProtocolV2Usb(path, name, data, options);
   }
 
   /**
@@ -959,19 +882,63 @@ export default class WebUsbTransport {
    * Release device
    */
   async release(path: string) {
-    const device: USBDevice = await this.findDevice(path);
-    const endpoints = this.deviceEndpoints.get(path);
-    const ifaceNum = endpoints?.interfaceNumber ?? this.interfaceId;
-    await device.releaseInterface(ifaceNum);
-    await device.close();
+    await this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
+    await this.closeOpenDevice(path);
     this.deviceProtocol.delete(path);
     this.deviceProtocolHints.delete(path);
-    this.protocolV2Assemblers.get(path)?.reset();
-    this.protocolV2Assemblers.delete(path);
-    this.protocolV2Sessions.delete(path);
     this.deviceEndpoints.delete(path);
   }
 
+  protected getProtocolV2UsbSchemas(): ProtocolV2Schemas {
+    if (!this.messages || !this.messagesV2) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+    return {
+      protocolV1: this.messages,
+      protocolV2: this.messagesV2,
+    };
+  }
+
+  protected getProtocolV2UsbLogger() {
+    return this.Log;
+  }
+
+  protected async writeProtocolV2UsbPacket(
+    path: string,
+    frame: Uint8Array,
+    _context: ProtocolV2CallContext
+  ): Promise<void> {
+    await this.transferOutOnce(path, frame);
+  }
+
+  protected async readProtocolV2UsbPacket(
+    path: string,
+    _context: ProtocolV2CallContext
+  ): Promise<Uint8Array> {
+    const dataView = await this.transferInOnce(path, PROTOCOL_V2_FRAME_MAX_BYTES);
+    return new Uint8Array(
+      this.toArrayBuffer(
+        dataView.buffer.slice(dataView.byteOffset, dataView.byteOffset + dataView.byteLength)
+      )
+    );
+  }
+
+  protected async resetProtocolV2UsbNativeLink(path: string, _reason: string): Promise<void> {
+    await this.closeOpenDevice(path);
+  }
+
+  protected onProtocolV2UsbLinkInvalidated(path: string, reason: string) {
+    this.deviceProtocol.delete(path);
+    this.Log?.debug(`[WebUsbTransport] Protocol V2 link invalidated: ${path}`, reason);
+  }
+
+  protected createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error {
+    return new ProtocolV2LinkError(
+      'response-timeout',
+      `Protocol V2 response timeout after ${timeoutMs}ms for ${name}`
+    );
+  }
+
   /**
    * Expose the detected protocol type for a given device path.
    * Used by upper layers (e.g. TransportManager) to select the correct schema.