@onekeyfe/hd-transport-web-device 1.1.27-alpha.4 → 1.1.27-alpha.41

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

@@ -0,0 +1,231 @@
+import transport, { PROTOCOL_V2_CHANNEL_BLE_UART, bytesToHex } from '@onekeyfe/hd-transport';
+
+import ElectronBleTransport from '../src/electron-ble-transport';
+
+const { ProtocolV1, ProtocolV2, parseConfigure } = transport;
+
+const protocolV1Schema = {
+  nested: {
+    Initialize: {
+      fields: {},
+    },
+    Success: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Initialize: 1,
+        MessageType_Success: 2,
+      },
+    },
+  },
+};
+
+const protocolV2Schema = {
+  nested: {
+    Ping: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    Success: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+const schemas = {
+  protocolV1: parseConfigure(protocolV1Schema),
+  protocolV2: parseConfigure(protocolV2Schema),
+};
+
+jest.setTimeout(10_000);
+
+const createLogger = () => ({
+  debug: jest.fn(),
+  error: jest.fn(),
+});
+
+const createNobleBle = (device = { id: 'flaky-pro2-id', name: 'Unknown BLE Device' }) => ({
+  enumerate: jest.fn(() => Promise.resolve([device])),
+  getDevice: jest.fn(() => Promise.resolve(device)),
+  connect: jest.fn(() => Promise.resolve()),
+  disconnect: jest.fn(() => Promise.resolve()),
+  subscribe: jest.fn(() => Promise.resolve()),
+  unsubscribe: jest.fn(() => Promise.resolve()),
+  write: jest.fn(() => Promise.resolve()),
+  onNotification: jest.fn(() => jest.fn()),
+  onDeviceDisconnected: jest.fn(() => jest.fn()),
+  checkAvailability: jest.fn(() =>
+    Promise.resolve({
+      available: true,
+      state: 'poweredOn',
+      unsupported: false,
+      initialized: true,
+    })
+  ),
+});
+
+const configureTransport = (nobleBle: ReturnType<typeof createNobleBle>) => {
+  (global as any).window = {
+    desktopApi: {
+      nobleBle,
+    },
+  };
+
+  const transport = new ElectronBleTransport();
+  transport.init(createLogger());
+  transport.configure(protocolV1Schema);
+  transport.configureProtocolV2(protocolV2Schema);
+  return transport;
+};
+
+describe('ElectronBleTransport protocol detection', () => {
+  afterEach(() => {
+    delete (global as any).window;
+    jest.clearAllMocks();
+  });
+
+  test('detects Protocol V2 after Protocol V1 probe timeout', async () => {
+    const device = { id: 'unknown-pro2-id', name: 'Unknown BLE Device' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    let writeCount = 0;
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      {
+        message: 'probe',
+      },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      writeCount += 1;
+      if (writeCount > 1) {
+        setTimeout(() => notificationHandler?.(device.id, bytesToHex(probeResponse)), 0);
+      }
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await expect(transport.acquire({ uuid: device.id })).resolves.toEqual(
+        expect.objectContaining({
+          uuid: device.id,
+          protocolType: 'V2',
+        })
+      );
+      expect(transport.getProtocolType(device.id)).toBe('V2');
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('detects Protocol V1 when device responds to Initialize', async () => {
+    const device = { id: 'classic-id', name: 'OneKey Classic' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+
+    // Build a V1 Success notification (no 64-byte padding, matching real BLE behaviour).
+    // Format: ?## (3f2323) + typeId BE (0002) + length BE (00000004) + protobuf payload (0a026f6b)
+    const v1ResponseHex = '3f23230002000000040a026f6b';
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      // Respond to first write (V1 Initialize probe) with V1 Success
+      setTimeout(() => notificationHandler?.(device.id, v1ResponseHex), 0);
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await expect(transport.acquire({ uuid: device.id })).resolves.toEqual(
+        expect.objectContaining({
+          uuid: device.id,
+        })
+      );
+      expect(transport.getProtocolType(device.id)).toBe('V1');
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('throws when both protocol probes fail', async () => {
+    const device = { id: 'dead-device-id', name: 'Unknown Device' };
+    const nobleBle = createNobleBle(device);
+
+    // Never respond to writes — both probes will timeout
+    nobleBle.onNotification.mockImplementation(() => jest.fn());
+
+    const transport = configureTransport(nobleBle);
+
+    await expect(transport.acquire({ uuid: device.id })).rejects.toThrow(
+      /Unable to detect BLE protocol/
+    );
+    expect(transport.getProtocolType(device.id)).toBeUndefined();
+  });
+
+  test('probes Protocol V2 instead of trusting the Pro2 name hint', async () => {
+    const device = { id: 'named-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      {
+        message: 'probe',
+      },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(probeResponse)), 0);
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await expect(transport.acquire({ uuid: device.id })).resolves.toEqual(
+        expect.objectContaining({
+          uuid: device.id,
+          protocolType: 'V2',
+        })
+      );
+      expect(nobleBle.write).toHaveBeenCalledTimes(1);
+      expect(transport.getProtocolType(device.id)).toBe('V2');
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+});

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

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import transport from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type EventEmitter from 'events';
 import type { DesktopAPI } from '@onekeyfe/hd-transport-electron';
+import type { OneKeyDeviceInfo, ProtocolType, TransportCallOptions } from '@onekeyfe/hd-transport';
+import type EventEmitter from 'events';
 declare global {
     interface Window {
         desktopApi?: DesktopAPI;
@@ -11,34 +11,71 @@ declare global {
 export type BleAcquireInput = {
     uuid: string;
     forceCleanRunPromise?: boolean;
+    expectedProtocol?: ProtocolType;
 };
 export default class ElectronBleTransport {
-    _messages: ReturnType<typeof transport.parseConfigure> | undefined;
+    private _messages;
+    private _messagesV2;
     name: string;
     configured: boolean;
-    runPromise: Deferred<any> | null;
+    runPromise: Deferred<Uint8Array | string> | null;
     Log?: any;
     emitter?: EventEmitter;
     private connectedDevices;
-    private dataBuffers;
+    private deviceProtocol;
+    private deviceProtocolHints;
+    private v1Buffers;
+    private v2Assemblers;
+    private v2FrameQueues;
+    private v2FramePromises;
+    private activeProtocolV2Call;
+    private nextProtocolV2CallToken;
     private notificationCleanups;
     private disconnectCleanups;
+    private notificationTokens;
+    private nextNotificationToken;
     private handleBluetoothError;
     private cleanupDeviceState;
     init(logger: any, emitter?: EventEmitter): void;
     configure(signedData: any): void;
-    listen(): void;
-    enumerate(): Promise<{
-        id: string;
-        name: string;
-    }[]>;
+    configureProtocolV2(signedData: any): void;
+    listen(): Promise<OneKeyDeviceInfo[]>;
+    enumerate(): Promise<OneKeyDeviceInfo[]>;
     acquire(input: BleAcquireInput): Promise<{
         uuid: string;
+        commType: import("@onekeyfe/hd-transport").OneKeyDeviceCommType;
         path: string;
+        session?: string | null | undefined;
+        debugSession?: string | null | undefined;
+        debug: boolean;
+        id: string;
+        name: string | null;
+        protocolType?: ProtocolType | undefined;
     }>;
     release(id: string): Promise<void>;
-    private handleNotificationData;
-    call(uuid: string, name: string, data: Record<string, unknown>): Promise<import("@onekeyfe/hd-transport").MessageFromOneKey>;
-    private processNotificationPacket;
+    private createProtocolMismatchError;
+    private createProtocolDetectionError;
+    private clearProbeProtocol;
+    private detectProtocol;
+    private createNotificationSubscription;
+    private resetProbeStateAfterProtocolProbe;
+    private probeProtocolV1;
+    private probeProtocolV2;
+    private writeWithChunking;
+    private writeWithRetry;
+    private handleNotification;
+    private handleProtocolV2Notification;
+    private getProtocolV2FrameQueue;
+    private resolveProtocolV2Frame;
+    private rejectAllProtocolV2Frames;
+    private resetProtocolV2Frames;
+    private isActiveProtocolV2Call;
+    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 processProtocolV1Notification;
+    getProtocolType(path: string): ProtocolType | undefined;
 }
 //# sourceMappingURL=electron-ble-transport.d.ts.map

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":";AAAA,OAAO,SAAkD,MAAM,wBAAwB,CAAC;AASxF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AAEvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAKlE,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;CAChC,CAAC;AASF,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,SAAS,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEnE,IAAI,SAA0B;IAE9B,UAAU,UAAS;IAEnB,UAAU,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAExC,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAGvB,OAAO,CAAC,gBAAgB,CAA0B;IAGlD,OAAO,CAAC,WAAW,CAAsE;IAGzF,OAAO,CAAC,oBAAoB,CAAsC;IAGlE,OAAO,CAAC,kBAAkB,CAAsC;IAGhE,OAAO,CAAC,oBAAoB;IAmC5B,OAAO,CAAC,kBAAkB;IAmB1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAexC,SAAS,CAAC,UAAU,EAAE,GAAG;IAMzB,MAAM;IAEA,SAAS,IAAI,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAcpD,OAAO,CAAC,KAAK,EAAE,eAAe;;;;IA8E9B,OAAO,CAAC,EAAE,EAAE,MAAM;IAwBxB,OAAO,CAAC,sBAAsB;IA2BxB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA2EpE,OAAO,CAAC,yBAAyB;CAyDlC"}
+{"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;AAWvC,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;IAkD5B,OAAO,CAAC,8BAA8B;YAgBxB,iCAAiC;YAoCjC,eAAe;YAgBf,eAAe;YAuBf,iBAAiB;YAsBjB,cAAc;IA4B5B,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,4BAA4B;IA6BpC,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"}

package/dist/index.d.ts

@@ -1,15 +1,21 @@
-import * as transport from '@onekeyfe/hd-transport';
-import transport__default, { AcquireInput, OneKeyDeviceInfoBase } from '@onekeyfe/hd-transport';
+import * as _onekeyfe_hd_transport from '@onekeyfe/hd-transport';
+import _onekeyfe_hd_transport__default, { AcquireInput, TransportCallOptions, ProtocolType, OneKeyDeviceInfoBase, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 import { Deferred } from '@onekeyfe/hd-shared';
-import EventEmitter from 'events';
 import { DesktopAPI } from '@onekeyfe/hd-transport-electron';
+import EventEmitter from 'events';
 
 interface DeviceInfo extends OneKeyDeviceInfoBase {
     path: string;
     device: USBDevice;
+    protocolType?: ProtocolType;
 }
 declare class WebUsbTransport {
-    messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
+    messages: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
+    messagesV2: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
+    private deviceProtocol;
+    private deviceProtocolHints;
+    private protocolV2Assemblers;
+    private deviceEndpoints;
     name: string;
     stopped: boolean;
     configured: boolean;
@@ -21,12 +27,17 @@ declare class WebUsbTransport {
     interfaceId: number;
     init(logger: any): void;
     configure(signedData: any): void;
+    configureProtocolV2(signedData: any): void;
     promptDeviceAccess(): Promise<USBDevice | null>;
     enumerate(): Promise<DeviceInfo[]>;
     getConnectedDevices(): Promise<DeviceInfo[]>;
     acquire(input: AcquireInput): Promise<string | undefined>;
+    private createProtocolMismatchError;
+    private createProtocolDetectionError;
+    private detectProtocol;
     findDevice(path: string): Promise<USBDevice>;
     connect(path: string, first: boolean): Promise<void>;
+    private discoverEndpoints;
     connectToDevice(path: string, first: boolean): Promise<void>;
     post(session: string, name: string, data: Record<string, unknown>): Promise<void>;
     private getErrorMessage;
@@ -36,9 +47,17 @@ declare class WebUsbTransport {
     private toArrayBuffer;
     private transferOutWithRetry;
     private transferInWithRetry;
-    call(path: string, name: string, data: Record<string, unknown>): Promise<transport.MessageFromOneKey>;
-    receiveData(path: string): Promise<string>;
+    private resetConnectionAfterProbe;
+    private withProtocolReadTimeout;
+    private probeProtocolV1;
+    private probeProtocolV2;
+    call(path: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<_onekeyfe_hd_transport.MessageFromOneKey>;
+    private callProtocolV1;
+    private callProtocolV2;
+    private receiveProtocolV2Frame;
+    receiveData(path: string, timeoutMs?: number): Promise<string>;
     release(path: string): Promise<void>;
+    getProtocolType(path: string): ProtocolType | undefined;
 }
 
 declare global {
@@ -49,35 +68,72 @@ declare global {
 type BleAcquireInput = {
     uuid: string;
     forceCleanRunPromise?: boolean;
+    expectedProtocol?: ProtocolType;
 };
 declare class ElectronBleTransport {
-    _messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
+    private _messages;
+    private _messagesV2;
     name: string;
     configured: boolean;
-    runPromise: Deferred<any> | null;
+    runPromise: Deferred<Uint8Array | string> | null;
     Log?: any;
     emitter?: EventEmitter;
     private connectedDevices;
-    private dataBuffers;
+    private deviceProtocol;
+    private deviceProtocolHints;
+    private v1Buffers;
+    private v2Assemblers;
+    private v2FrameQueues;
+    private v2FramePromises;
+    private activeProtocolV2Call;
+    private nextProtocolV2CallToken;
     private notificationCleanups;
     private disconnectCleanups;
+    private notificationTokens;
+    private nextNotificationToken;
     private handleBluetoothError;
     private cleanupDeviceState;
     init(logger: any, emitter?: EventEmitter): void;
     configure(signedData: any): void;
-    listen(): void;
-    enumerate(): Promise<{
-        id: string;
-        name: string;
-    }[]>;
+    configureProtocolV2(signedData: any): void;
+    listen(): Promise<OneKeyDeviceInfo[]>;
+    enumerate(): Promise<OneKeyDeviceInfo[]>;
     acquire(input: BleAcquireInput): Promise<{
         uuid: string;
+        commType: _onekeyfe_hd_transport.OneKeyDeviceCommType;
         path: string;
+        session?: string | null | undefined;
+        debugSession?: string | null | undefined;
+        debug: boolean;
+        id: string;
+        name: string | null;
+        protocolType?: ProtocolType | undefined;
     }>;
     release(id: string): Promise<void>;
-    private handleNotificationData;
-    call(uuid: string, name: string, data: Record<string, unknown>): Promise<transport.MessageFromOneKey>;
-    private processNotificationPacket;
+    private createProtocolMismatchError;
+    private createProtocolDetectionError;
+    private clearProbeProtocol;
+    private detectProtocol;
+    private createNotificationSubscription;
+    private resetProbeStateAfterProtocolProbe;
+    private probeProtocolV1;
+    private probeProtocolV2;
+    private writeWithChunking;
+    private writeWithRetry;
+    private handleNotification;
+    private handleProtocolV2Notification;
+    private getProtocolV2FrameQueue;
+    private resolveProtocolV2Frame;
+    private rejectAllProtocolV2Frames;
+    private resetProtocolV2Frames;
+    private isActiveProtocolV2Call;
+    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 processProtocolV1Notification;
+    getProtocolType(path: string): ProtocolType | undefined;
 }
 
 export { ElectronBleTransport, WebUsbTransport };