@onekeyfe/hd-common-connect-sdk 1.2.8 → 1.2.10-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -28,6 +28,33 @@ function init() {
28
28
  }
29
29
  ```
30
30
 
31
+ ## Desktop USB identity discovery
32
+
33
+ `probeUsbDeviceIdentities({ commType: 'webusb' | 'bridge' })` is a named export for
34
+ choosing a Desktop connection before switching the active SDK. It does not require
35
+ SDK initialization, dispose Core, change BLE settings, or open a wallet session.
36
+ Concurrent probes for the same mode share one pending request.
37
+
38
+ ```typescript
39
+ import { probeUsbDeviceIdentities } from '@onekeyfe/hd-common-connect-sdk';
40
+
41
+ const devices = await probeUsbDeviceIdentities({ commType: 'webusb' });
42
+ ```
43
+
44
+ Each result contains `path`, `serialNo`, `deviceId`, `deviceType`, `connectProtocol`,
45
+ and `commType`. `path` locates the USB endpoint; compare `serialNo` with the target's
46
+ physical identity, or `deviceId` for legacy devices without a physical serial.
47
+ Missing identities remain `null`; a descriptor path is never substituted for them.
48
+ The protocol comes from an active device response. V1 uses read-only Features;
49
+ V2 uses hardware DeviceInfo and does not query a wallet session.
50
+
51
+ Busy, ambiguous, disconnected, or unverified endpoints are omitted. An active
52
+ WebUSB request's identity can be reused only for the exact USB handle it owns.
53
+ Discovery releases only handles it acquired and does not replace the active SDK's
54
+ disconnect observer. An empty result is not proof that the device is absent.
55
+ Keep the selected transport fixed during a hardware operation; reevaluate it
56
+ between operations. Firmware updates must separately validate their live target.
57
+
31
58
  ## Docs
32
59
 
33
60
  Documentation is available [Hardware SDK Getting Started](https://developer.onekey.so/en/hardware-sdk/getting-started)
@@ -1,10 +1,16 @@
1
1
  import { readFileSync } from 'fs';
2
2
  import { resolve } from 'path';
3
3
  import EventEmitter from 'events';
4
- import { CORE_EVENT, initCore } from '@onekeyfe/hd-core';
5
- import { createDeferred } from '@onekeyfe/hd-shared';
4
+ import {
5
+ CORE_EVENT,
6
+ UI_REQUEST,
7
+ initCore,
8
+ probeUsbDeviceIdentitiesWithTransport,
9
+ } from '@onekeyfe/hd-core';
10
+ import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
11
+ import HttpTransport from '@onekeyfe/hd-transport-http';
6
12
 
7
- import sdkExport, { messagePromises } from '../src';
13
+ import sdkExport, { messagePromises, probeUsbDeviceIdentities } from '../src';
8
14
 
9
15
  jest.mock('../../core/src/data/config', () => ({
10
16
  getSDKVersion: jest.fn(() => '1.0.0-test'),
@@ -15,9 +21,10 @@ jest.mock('@onekeyfe/hd-core', () => ({
15
21
  __esModule: true,
16
22
  default: (options: unknown) => options,
17
23
  initCore: jest.fn(),
24
+ probeUsbDeviceIdentitiesWithTransport: jest.fn(),
18
25
  }));
19
- jest.mock('@onekeyfe/hd-transport-http', () => ({}));
20
- jest.mock('@onekeyfe/hd-transport-web-device', () => ({}));
26
+ jest.mock('@onekeyfe/hd-transport-http', () => ({ __esModule: true, default: jest.fn() }));
27
+ jest.mock('@onekeyfe/hd-transport-web-device', () => ({ WebUsbTransport: jest.fn() }));
21
28
  jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
22
29
  jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
23
30
 
@@ -56,6 +63,17 @@ describe('SDK request cleanup', () => {
56
63
  await sdk.dispose();
57
64
  });
58
65
 
66
+ test.each([
67
+ [HardwareErrorCode.BlePoweredOff, UI_REQUEST.BLUETOOTH_POWERED_OFF],
68
+ [HardwareErrorCode.BleUnsupported, UI_REQUEST.BLUETOOTH_UNSUPPORTED],
69
+ [HardwareErrorCode.BleLocationError, UI_REQUEST.LOCATION_PERMISSION],
70
+ ])('emits the adapter UI request for error %s', async (code, type) => {
71
+ const response = { success: false, payload: { code, error: 'Adapter unavailable' } };
72
+ core.handleMessage.mockResolvedValueOnce(response);
73
+ await expect(sdk.call({ method: 'searchDevices' })).resolves.toEqual(response);
74
+ expect(core.handleMessage).toHaveBeenNthCalledWith(2, expect.objectContaining({ type }));
75
+ });
76
+
59
77
  test('removes only the completed request when calls settle out of order', async () => {
60
78
  const first = createDeferred<unknown>();
61
79
  const second = createDeferred<unknown>();
@@ -71,6 +89,45 @@ describe('SDK request cleanup', () => {
71
89
  expect(Object.keys(messagePromises)).toHaveLength(0);
72
90
  });
73
91
 
92
+ test.each(['webusb'] as const)(
93
+ 'probes %s without disposing an outstanding BLE request and coalesces concurrent probes',
94
+ async commType => {
95
+ const pending = createDeferred<unknown>();
96
+ const discovery = createDeferred<never[]>();
97
+ core.handleMessage.mockReturnValueOnce(pending.promise);
98
+ const request = sdk.call({ method: 'getDeviceState' });
99
+ jest
100
+ .mocked(probeUsbDeviceIdentitiesWithTransport)
101
+ .mockReset()
102
+ .mockReturnValueOnce(discovery.promise);
103
+ const initializationCount = jest.mocked(initCore).mock.calls.length;
104
+ const first = probeUsbDeviceIdentities({ commType });
105
+ const second = probeUsbDeviceIdentities({ commType });
106
+ expect(second).toBe(first);
107
+ expect(probeUsbDeviceIdentitiesWithTransport).toHaveBeenCalledTimes(1);
108
+ discovery.resolve([]);
109
+ await first;
110
+ expect(core.dispose).not.toHaveBeenCalled();
111
+ expect(initCore).toHaveBeenCalledTimes(initializationCount);
112
+ expect(core.listenerCount(CORE_EVENT)).toBe(1);
113
+ expect(Object.keys(messagePromises)).toHaveLength(1);
114
+ pending.resolve({ success: true, payload: {} });
115
+ await expect(request).resolves.toMatchObject({ success: true });
116
+ expect(Object.keys(messagePromises)).toHaveLength(0);
117
+ }
118
+ );
119
+
120
+ test('rejects the withdrawn Bridge probe without creating a transport or affecting BLE', async () => {
121
+ jest.mocked(HttpTransport).mockClear();
122
+ jest.mocked(probeUsbDeviceIdentitiesWithTransport).mockClear();
123
+ await expect(probeUsbDeviceIdentities({ commType: 'bridge' })).rejects.toMatchObject({
124
+ errorCode: HardwareErrorCode.CallMethodInvalidParameter,
125
+ });
126
+ expect(HttpTransport).not.toHaveBeenCalled();
127
+ expect(probeUsbDeviceIdentitiesWithTransport).not.toHaveBeenCalled();
128
+ expect(core.dispose).not.toHaveBeenCalled();
129
+ });
130
+
74
131
  test('waits for Core disposal and does not retain old listeners after reinitialization', async () => {
75
132
  const cleanup = createDeferred<void>();
76
133
  core.dispose.mockImplementationOnce(async () => {
@@ -0,0 +1,103 @@
1
+ import EventEmitter from 'events';
2
+ import {
3
+ CORE_EVENT,
4
+ DEVICE,
5
+ DEVICE_EVENT,
6
+ UI_EVENT,
7
+ UI_REQUEST,
8
+ IFRAME,
9
+ initCore,
10
+ switchTransport,
11
+ } from '@onekeyfe/hd-core';
12
+
13
+ import { HardwareSDKLowLevel } from '../src';
14
+
15
+ jest.mock('../../core/src/data/config', () => ({
16
+ getSDKVersion: jest.fn(() => '1.0.0-test'),
17
+ DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
18
+ }));
19
+ jest.mock('@onekeyfe/hd-core', () => ({
20
+ __esModule: true,
21
+ ...jest.requireActual('@onekeyfe/hd-core'),
22
+ initCore: jest.fn(),
23
+ switchTransport: jest.fn(),
24
+ }));
25
+ jest.mock('@onekeyfe/hd-transport-http', () => ({}));
26
+ jest.mock('@onekeyfe/hd-transport-web-device', () => ({ WebUsbTransport: {} }));
27
+ jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
28
+ jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
29
+
30
+ const core = Object.assign(new EventEmitter(), {
31
+ handleMessage: jest.fn(),
32
+ dispose: jest.fn(() => {
33
+ core.removeAllListeners();
34
+ return Promise.resolve();
35
+ }),
36
+ });
37
+
38
+ beforeEach(() => {
39
+ jest.clearAllMocks();
40
+ initCore.mockResolvedValue(core);
41
+ });
42
+ afterEach(async () => HardwareSDKLowLevel.dispose());
43
+
44
+ test('initializes, calls and switches the local Core without a DOM or iframe', async () => {
45
+ expect(typeof document).toBe('undefined');
46
+ expect(await HardwareSDKLowLevel.init({ env: 'webusb' })).toBe(true);
47
+ expect(initCore).toHaveBeenCalledWith(
48
+ expect.objectContaining({ env: 'webusb' }),
49
+ expect.anything(),
50
+ undefined
51
+ );
52
+ const response = { success: true, payload: { test: true } };
53
+ core.handleMessage.mockResolvedValue(response);
54
+ expect(await HardwareSDKLowLevel.call({ method: 'getFeatures' })).toBe(response);
55
+ expect(core.handleMessage).toHaveBeenCalledWith(
56
+ expect.objectContaining({
57
+ event: IFRAME.CALL,
58
+ type: IFRAME.CALL,
59
+ payload: expect.objectContaining({ method: 'getFeatures' }),
60
+ })
61
+ );
62
+ expect(await HardwareSDKLowLevel.switchTransport('webusb')).toStrictEqual({
63
+ success: true,
64
+ payload: {},
65
+ });
66
+ expect(switchTransport).toHaveBeenCalledWith({
67
+ env: 'webusb',
68
+ Transport: expect.anything(),
69
+ plugin: undefined,
70
+ });
71
+ });
72
+
73
+ test('keeps the Web LowLevel event envelope and cleans listeners on dispose', async () => {
74
+ const listener = jest.fn();
75
+ HardwareSDKLowLevel.addHardwareGlobalEventListener(listener);
76
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
77
+ const payload = { device: { label: 'Synthetic device' } };
78
+ core.emit(CORE_EVENT, { event: DEVICE_EVENT, type: DEVICE.CONNECT, payload });
79
+ expect(listener).toHaveBeenLastCalledWith({
80
+ ...payload,
81
+ event: DEVICE.CONNECT,
82
+ type: DEVICE.CONNECT,
83
+ });
84
+ const message = { event: UI_EVENT, type: UI_REQUEST.REQUEST_BUTTON, payload: {} };
85
+ core.emit(CORE_EVENT, message);
86
+ expect(listener).toHaveBeenLastCalledWith(message);
87
+ await HardwareSDKLowLevel.dispose();
88
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
89
+ listener.mockClear();
90
+ core.emit(CORE_EVENT, message);
91
+ expect(listener).not.toHaveBeenCalled();
92
+ expect(core.listenerCount(CORE_EVENT)).toBe(1);
93
+ });
94
+
95
+ test('uses settings staged before initialization', async () => {
96
+ await HardwareSDKLowLevel.updateSettings({ env: 'webusb' });
97
+ await HardwareSDKLowLevel.init({ debug: false });
98
+ expect(initCore).toHaveBeenCalledWith(
99
+ expect.objectContaining({ env: 'webusb' }),
100
+ expect.anything(),
101
+ undefined
102
+ );
103
+ });
package/dist/index.d.ts CHANGED
@@ -1,9 +1,15 @@
1
1
  import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
2
+ import { UsbDeviceIdentity, LowLevelCoreApi } from '@onekeyfe/hd-core';
2
3
  import { Deferred } from '@onekeyfe/hd-shared';
3
4
 
5
+ /** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
6
+ declare const probeUsbDeviceIdentities: ({ commType, }: {
7
+ commType: UsbDeviceIdentity['commType'];
8
+ }) => Promise<UsbDeviceIdentity[]>;
4
9
  declare const messagePromises: {
5
10
  [key: number]: Deferred<any>;
6
11
  };
12
+ declare const HardwareSDKLowLevel: LowLevelCoreApi;
7
13
  declare const HardwareCommonConnectSdk: _onekeyfe_hd_core.CoreApi;
8
14
 
9
- export { HardwareCommonConnectSdk as default, messagePromises };
15
+ export { HardwareSDKLowLevel, HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
package/dist/index.js CHANGED
@@ -606,7 +606,32 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
606
606
  });
607
607
  }); };
608
608
  var _core;
609
+ var _plugin;
609
610
  var _settings = HardwareSdk.parseConnectSettings();
611
+ var usbIdentityProbeTransports = {};
612
+ var usbIdentityProbes = {};
613
+ /** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
614
+ var probeUsbDeviceIdentities = function (_a) {
615
+ var commType = _a.commType;
616
+ if (commType !== 'webusb') {
617
+ return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter));
618
+ }
619
+ var pending = usbIdentityProbes[commType];
620
+ if (pending)
621
+ return pending;
622
+ var transport = usbIdentityProbeTransports[commType];
623
+ if (!transport) {
624
+ transport = new hdTransportWebDevice.WebUsbTransport(true);
625
+ usbIdentityProbeTransports[commType] = transport;
626
+ }
627
+ var probe = HardwareSdk.probeUsbDeviceIdentitiesWithTransport(transport, commType, function (descriptor) {
628
+ return _core === null || _core === void 0 ? void 0 : _core.getOwnedUsbDeviceIdentity(descriptor);
629
+ }).finally(function () {
630
+ delete usbIdentityProbes[commType];
631
+ });
632
+ usbIdentityProbes[commType] = probe;
633
+ return probe;
634
+ };
610
635
  var _messageID = 0;
611
636
  var messagePromises = {};
612
637
  var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -617,6 +642,7 @@ var dispose = function () { return __awaiter(void 0, void 0, void 0, function ()
617
642
  case 0:
618
643
  core = _core;
619
644
  _core = undefined;
645
+ _plugin = undefined;
620
646
  eventEmitter.removeAllListeners();
621
647
  Object.keys(messagePromises).forEach(function (key) {
622
648
  delete messagePromises[Number(key)];
@@ -723,6 +749,7 @@ var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, voi
723
749
  return [4 /*yield*/, HardwareSdk.initCore(_settings, Transport, plugin)];
724
750
  case 3:
725
751
  _core = _b.sent();
752
+ _plugin = plugin;
726
753
  _core === null || _core === void 0 ? void 0 : _core.on(HardwareSdk.CORE_EVENT, handleMessage);
727
754
  HardwareSdk.setLoggerPostMessage(handleMessage);
728
755
  return [2 /*return*/, true];
@@ -736,18 +763,18 @@ var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, voi
736
763
  }); };
737
764
  var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
738
765
  var blockLog, response, error_2;
739
- var _a, _b, _c;
740
- return __generator(this, function (_d) {
741
- switch (_d.label) {
766
+ var _a, _b, _c, _d;
767
+ return __generator(this, function (_e) {
768
+ switch (_e.label) {
742
769
  case 0:
743
770
  blockLog = HardwareSdk.getLogBlockLabel(params);
744
771
  Log.debug('call: ', blockLog !== null && blockLog !== void 0 ? blockLog : params);
745
- _d.label = 1;
772
+ _e.label = 1;
746
773
  case 1:
747
- _d.trys.push([1, 3, , 4]);
774
+ _e.trys.push([1, 3, , 4]);
748
775
  return [4 /*yield*/, postMessage({ event: HardwareSdk.IFRAME.CALL, type: HardwareSdk.IFRAME.CALL, payload: params })];
749
776
  case 2:
750
- response = _d.sent();
777
+ response = _e.sent();
751
778
  if (response) {
752
779
  Log.debug('response: ', blockLog ? '[REDACTED]' : response);
753
780
  if (!response.success) {
@@ -760,12 +787,15 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
760
787
  if (((_c = response.payload) === null || _c === void 0 ? void 0 : _c.code) === hdShared.HardwareErrorCode.BlePermissionError) {
761
788
  postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_PERMISSION), false);
762
789
  }
790
+ if (((_d = response.payload) === null || _d === void 0 ? void 0 : _d.code) === hdShared.HardwareErrorCode.BleLocationError) {
791
+ postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.LOCATION_PERMISSION), false);
792
+ }
763
793
  }
764
794
  return [2 /*return*/, response];
765
795
  }
766
796
  return [2 /*return*/, HardwareSdk.createErrorMessage(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodNotResponse))];
767
797
  case 3:
768
- error_2 = _d.sent();
798
+ error_2 = _e.sent();
769
799
  Log.error('__call error: ', error_2);
770
800
  return [2 /*return*/, HardwareSdk.createErrorMessage(error_2)];
771
801
  case 4: return [2 /*return*/];
@@ -774,6 +804,62 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
774
804
  }); };
775
805
  var updateSettings = function () { return Promise.resolve(true); };
776
806
  var switchTransport = function () { return Promise.resolve({ success: true }); };
807
+ var addHardwareGlobalEventListener = function (listener) {
808
+ [
809
+ HardwareSdk.UI_EVENT,
810
+ HardwareSdk.LOG_EVENT,
811
+ HardwareSdk.FIRMWARE_EVENT,
812
+ HardwareSdk.DEVICE.CONNECT,
813
+ HardwareSdk.DEVICE.DISCONNECT,
814
+ HardwareSdk.DEVICE.FEATURES,
815
+ HardwareSdk.DEVICE.STATE,
816
+ HardwareSdk.DEVICE.SUPPORT_FEATURES,
817
+ HardwareSdk.UI_REQUEST.FIRMWARE_PROGRESS,
818
+ HardwareSdk.UI_REQUEST.FIRMWARE_TIP,
819
+ HardwareSdk.UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
820
+ ].forEach(function (eventName) {
821
+ eventEmitter.on(eventName, function (message) {
822
+ // Match the Web SDK envelope for device events emitted as payloads.
823
+ var envelope = message;
824
+ var emitMessage = message;
825
+ if (!envelope.event && !envelope.type) {
826
+ emitMessage = __assign({}, message);
827
+ Object.assign(emitMessage, { event: eventName, type: eventName });
828
+ }
829
+ listener(emitMessage);
830
+ });
831
+ });
832
+ };
833
+ var HardwareSDKLowLevel = HardwareSdk.HardwareSDKLowLevel({
834
+ eventEmitter: eventEmitter,
835
+ init: function (settings, sdk, plugin) { return init(__assign(__assign({}, _settings), settings), sdk, plugin); },
836
+ call: call,
837
+ cancel: cancel,
838
+ dispose: dispose,
839
+ addHardwareGlobalEventListener: addHardwareGlobalEventListener,
840
+ uiResponse: uiResponse,
841
+ updateSettings: function (settings) {
842
+ if (_core)
843
+ throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.IFrameAleradyInitialized);
844
+ _settings = HardwareSdk.parseConnectSettings(__assign(__assign({}, _settings), settings));
845
+ return Promise.resolve(true);
846
+ },
847
+ switchTransport: function (env) { return __awaiter(void 0, void 0, void 0, function () {
848
+ var Transport;
849
+ return __generator(this, function (_a) {
850
+ switch (_a.label) {
851
+ case 0:
852
+ if (!_core)
853
+ throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
854
+ return [4 /*yield*/, getTransport(env)];
855
+ case 1:
856
+ Transport = _a.sent();
857
+ HardwareSdk.switchTransport({ env: env, Transport: Transport, plugin: _plugin });
858
+ return [2 /*return*/, { success: true, payload: {} }];
859
+ }
860
+ });
861
+ }); },
862
+ });
777
863
  var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
778
864
  eventEmitter: eventEmitter,
779
865
  init: init,
@@ -785,5 +871,7 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
785
871
  switchTransport: switchTransport,
786
872
  });
787
873
 
874
+ exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
788
875
  exports["default"] = HardwareCommonConnectSdk;
789
876
  exports.messagePromises = messagePromises;
877
+ exports.probeUsbDeviceIdentities = probeUsbDeviceIdentities;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@onekeyfe/hd-common-connect-sdk",
3
- "version": "1.2.8",
3
+ "version": "1.2.10-alpha.2",
4
4
  "author": "OneKey",
5
5
  "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
6
6
  "license": "ISC",
@@ -21,13 +21,13 @@
21
21
  "lint:fix": "eslint . --fix"
22
22
  },
23
23
  "dependencies": {
24
- "@onekeyfe/hd-core": "1.2.8",
25
- "@onekeyfe/hd-shared": "1.2.8",
26
- "@onekeyfe/hd-transport-emulator": "1.2.8",
27
- "@onekeyfe/hd-transport-http": "1.2.8",
28
- "@onekeyfe/hd-transport-lowlevel": "1.2.8",
29
- "@onekeyfe/hd-transport-usb": "1.2.8",
30
- "@onekeyfe/hd-transport-web-device": "1.2.8"
24
+ "@onekeyfe/hd-core": "1.2.10-alpha.2",
25
+ "@onekeyfe/hd-shared": "1.2.10-alpha.2",
26
+ "@onekeyfe/hd-transport-emulator": "1.2.10-alpha.2",
27
+ "@onekeyfe/hd-transport-http": "1.2.10-alpha.2",
28
+ "@onekeyfe/hd-transport-lowlevel": "1.2.10-alpha.2",
29
+ "@onekeyfe/hd-transport-usb": "1.2.10-alpha.2",
30
+ "@onekeyfe/hd-transport-web-device": "1.2.10-alpha.2"
31
31
  },
32
- "gitHead": "9f016278a7f395bf66b8502815dc63191e162fd3"
32
+ "gitHead": "2bcc72a43379abb005405f18f914330f3f2dbfd7"
33
33
  }
package/src/index.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  import EventEmitter from 'events';
2
2
  import HardwareSdk, {
3
+ HardwareSDKLowLevel as HardwareLowLevelSdk,
3
4
  CORE_EVENT,
4
5
  DEVICE,
5
6
  DEVICE_EVENT,
@@ -17,7 +18,9 @@ import HardwareSdk, {
17
18
  getLogger,
18
19
  initCore,
19
20
  parseConnectSettings,
21
+ probeUsbDeviceIdentitiesWithTransport,
20
22
  setLoggerPostMessage,
23
+ switchTransport as switchCoreTransport,
21
24
  } from '@onekeyfe/hd-core';
22
25
  import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
23
26
  import HttpTransport from '@onekeyfe/hd-transport-http';
@@ -32,6 +35,7 @@ import type {
32
35
  CoreMessage,
33
36
  LowLevelCoreApi,
34
37
  UiResponseEvent,
38
+ UsbDeviceIdentity,
35
39
  } from '@onekeyfe/hd-core';
36
40
  import type { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
37
41
 
@@ -55,14 +59,47 @@ const getTransport = async (env: ConnectSettings['env']) => {
55
59
  };
56
60
 
57
61
  let _core: Core | undefined;
62
+ let _plugin: LowlevelTransportSharedPlugin | undefined;
58
63
  let _settings = parseConnectSettings();
59
64
 
65
+ const usbIdentityProbeTransports: Partial<Record<UsbDeviceIdentity['commType'], WebUsbTransport>> =
66
+ {};
67
+ const usbIdentityProbes: Partial<
68
+ Record<UsbDeviceIdentity['commType'], Promise<UsbDeviceIdentity[]>>
69
+ > = {};
70
+
71
+ /** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
72
+ export const probeUsbDeviceIdentities = ({
73
+ commType,
74
+ }: {
75
+ commType: UsbDeviceIdentity['commType'];
76
+ }): Promise<UsbDeviceIdentity[]> => {
77
+ if (commType !== 'webusb') {
78
+ return Promise.reject(ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter));
79
+ }
80
+ const pending = usbIdentityProbes[commType];
81
+ if (pending) return pending;
82
+ let transport = usbIdentityProbeTransports[commType];
83
+ if (!transport) {
84
+ transport = new WebUsbTransport(true);
85
+ usbIdentityProbeTransports[commType] = transport;
86
+ }
87
+ const probe = probeUsbDeviceIdentitiesWithTransport(transport, commType, descriptor =>
88
+ _core?.getOwnedUsbDeviceIdentity(descriptor)
89
+ ).finally(() => {
90
+ delete usbIdentityProbes[commType];
91
+ });
92
+ usbIdentityProbes[commType] = probe;
93
+ return probe;
94
+ };
95
+
60
96
  let _messageID = 0;
61
97
  export const messagePromises: { [key: number]: Deferred<any> } = {};
62
98
 
63
99
  const dispose = async () => {
64
100
  const core = _core;
65
101
  _core = undefined;
102
+ _plugin = undefined;
66
103
  eventEmitter.removeAllListeners();
67
104
  Object.keys(messagePromises).forEach(key => {
68
105
  delete messagePromises[Number(key)];
@@ -158,6 +195,7 @@ const init = async (
158
195
  try {
159
196
  const Transport = await getTransport(_settings.env);
160
197
  _core = await initCore(_settings, Transport, plugin);
198
+ _plugin = plugin;
161
199
  _core?.on(CORE_EVENT, handleMessage);
162
200
  setLoggerPostMessage(handleMessage);
163
201
 
@@ -188,6 +226,9 @@ const call = async (params: any) => {
188
226
  if (response.payload?.code === HardwareErrorCode.BlePermissionError) {
189
227
  postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_PERMISSION), false);
190
228
  }
229
+ if (response.payload?.code === HardwareErrorCode.BleLocationError) {
230
+ postMessage(createUiMessage(UI_REQUEST.LOCATION_PERMISSION), false);
231
+ }
191
232
  }
192
233
 
193
234
  return response;
@@ -203,6 +244,54 @@ const call = async (params: any) => {
203
244
  const updateSettings = () => Promise.resolve(true);
204
245
  const switchTransport = () => Promise.resolve({ success: true });
205
246
 
247
+ const addHardwareGlobalEventListener = (listener: (message: CoreMessage) => void) => {
248
+ [
249
+ UI_EVENT,
250
+ LOG_EVENT,
251
+ FIRMWARE_EVENT,
252
+ DEVICE.CONNECT,
253
+ DEVICE.DISCONNECT,
254
+ DEVICE.FEATURES,
255
+ DEVICE.STATE,
256
+ DEVICE.SUPPORT_FEATURES,
257
+ UI_REQUEST.FIRMWARE_PROGRESS,
258
+ UI_REQUEST.FIRMWARE_TIP,
259
+ UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
260
+ ].forEach(eventName => {
261
+ eventEmitter.on(eventName, (message: CoreMessage) => {
262
+ // Match the Web SDK envelope for device events emitted as payloads.
263
+ const envelope: { event?: string; type?: string } = message;
264
+ let emitMessage = message;
265
+ if (!envelope.event && !envelope.type) {
266
+ emitMessage = { ...message };
267
+ Object.assign(emitMessage, { event: eventName, type: eventName });
268
+ }
269
+ listener(emitMessage);
270
+ });
271
+ });
272
+ };
273
+
274
+ export const HardwareSDKLowLevel = HardwareLowLevelSdk({
275
+ eventEmitter,
276
+ init: (settings, sdk, plugin) => init({ ..._settings, ...settings }, sdk, plugin),
277
+ call,
278
+ cancel,
279
+ dispose,
280
+ addHardwareGlobalEventListener,
281
+ uiResponse,
282
+ updateSettings: (settings: Partial<ConnectSettings>) => {
283
+ if (_core) throw ERRORS.TypedError(HardwareErrorCode.IFrameAleradyInitialized);
284
+ _settings = parseConnectSettings({ ..._settings, ...settings });
285
+ return Promise.resolve(true);
286
+ },
287
+ switchTransport: async (env: ConnectSettings['env']) => {
288
+ if (!_core) throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
289
+ const Transport = await getTransport(env);
290
+ switchCoreTransport({ env, Transport, plugin: _plugin });
291
+ return { success: true, payload: {} };
292
+ },
293
+ });
294
+
206
295
  const HardwareCommonConnectSdk = HardwareSdk({
207
296
  eventEmitter,
208
297
  init,