@onekeyfe/hd-common-connect-sdk 1.2.11-alpha.8 → 1.2.11-alpha.9

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
@@ -1,6 +1,6 @@
1
1
  # `@onekeyfe/hd-common-connect-sdk`
2
2
 
3
- `@onekeyfe/hd-common-connect-sdk` is a libarary that runs in the node enviroment. And communicates with transport in the normal way.
3
+ `@onekeyfe/hd-common-connect-sdk` is a unified in-process Hardware SDK entry point that runs Core and the selected transport directly in Node.js, Electron, browser/extension, and native bridge (`lowlevel`) runtimes.
4
4
 
5
5
  ## Installation
6
6
 
@@ -28,6 +28,29 @@ function init() {
28
28
  }
29
29
  ```
30
30
 
31
+ ## Local LowLevel host
32
+
33
+ The named `HardwareSDKLowLevel` export runs Core and the selected transport in the
34
+ same JavaScript runtime. A trusted local host, including an extension offscreen
35
+ document, can use it without a hardware SDK iframe:
36
+
37
+ ```typescript
38
+ import { HardwareSDKLowLevel } from '@onekeyfe/hd-common-connect-sdk';
39
+
40
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
41
+ // Forward SDK calls and correlated UI responses through the host's existing bridge.
42
+ await HardwareSDKLowLevel.dispose();
43
+ ```
44
+
45
+ The package's `browser` mapping excludes the native USB dependency from browser
46
+ bundles. The browser host still needs a `Buffer` polyfill for Core and its
47
+ dependencies. Use `env: 'node-usb'` from a Node.js build.
48
+
49
+ The host still obtains WebUSB permission through a user gesture and handles device
50
+ confirmation, PIN and passphrase events. An extension service worker should proxy
51
+ to its offscreen host. Use one active SDK host per runtime and dispose it before
52
+ replacing it. The package's default SDK export keeps its existing behavior.
53
+
31
54
  ## Desktop USB identity discovery
32
55
 
33
56
  `probeUsbDeviceIdentities({ commType: 'webusb' | 'bridge' })` is a named export for
@@ -0,0 +1,249 @@
1
+ import EventEmitter from 'events';
2
+ import {
3
+ CORE_EVENT,
4
+ DEVICE,
5
+ DEVICE_EVENT,
6
+ UI_EVENT,
7
+ UI_REQUEST,
8
+ IFRAME,
9
+ UI_RESPONSE,
10
+ initCore,
11
+ switchTransport,
12
+ } from '@onekeyfe/hd-core';
13
+ import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
14
+
15
+ import { HardwareSDKLowLevel } from '../src';
16
+
17
+ jest.mock('../../core/src/data/config', () => ({
18
+ getSDKVersion: jest.fn(() => '1.0.0-test'),
19
+ DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
20
+ }));
21
+ jest.mock('@onekeyfe/hd-core', () => ({
22
+ __esModule: true,
23
+ ...jest.requireActual('@onekeyfe/hd-core'),
24
+ initCore: jest.fn(),
25
+ switchTransport: jest.fn(),
26
+ }));
27
+ jest.mock('@onekeyfe/hd-transport-http', () => ({}));
28
+ jest.mock('@onekeyfe/hd-transport-web-device', () => ({ WebUsbTransport: {} }));
29
+ jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
30
+ jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
31
+
32
+ const core = Object.assign(new EventEmitter(), {
33
+ handleMessage: jest.fn(),
34
+ dispose: jest.fn(() => {
35
+ core.removeAllListeners();
36
+ return Promise.resolve();
37
+ }),
38
+ });
39
+
40
+ beforeEach(() => {
41
+ jest.clearAllMocks();
42
+ initCore.mockResolvedValue(core);
43
+ });
44
+ afterEach(async () => HardwareSDKLowLevel.dispose());
45
+
46
+ test('initializes, calls and switches the local Core without a DOM or iframe', async () => {
47
+ expect(typeof document).toBe('undefined');
48
+ expect(await HardwareSDKLowLevel.init({ env: 'webusb' })).toBe(true);
49
+ expect(initCore).toHaveBeenCalledWith(
50
+ expect.objectContaining({ env: 'webusb' }),
51
+ expect.anything(),
52
+ undefined,
53
+ expect.any(AbortSignal)
54
+ );
55
+ const response = { success: true, payload: { test: true } };
56
+ core.handleMessage.mockResolvedValue(response);
57
+ expect(await HardwareSDKLowLevel.call({ method: 'getFeatures' })).toBe(response);
58
+ expect(core.handleMessage).toHaveBeenCalledWith(
59
+ expect.objectContaining({
60
+ event: IFRAME.CALL,
61
+ type: IFRAME.CALL,
62
+ payload: expect.objectContaining({ method: 'getFeatures' }),
63
+ })
64
+ );
65
+ expect(await HardwareSDKLowLevel.switchTransport('webusb')).toStrictEqual({
66
+ success: true,
67
+ payload: {},
68
+ });
69
+ expect(switchTransport).toHaveBeenCalledWith({
70
+ env: 'webusb',
71
+ owner: core,
72
+ loadTransport: expect.any(Function),
73
+ plugin: undefined,
74
+ });
75
+ });
76
+
77
+ test('keeps the Web LowLevel event envelope and cleans listeners on dispose', async () => {
78
+ const listener = jest.fn();
79
+ HardwareSDKLowLevel.addHardwareGlobalEventListener(listener);
80
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
81
+ const payload = { device: { label: 'Synthetic device' } };
82
+ core.emit(CORE_EVENT, { event: DEVICE_EVENT, type: DEVICE.CONNECT, payload });
83
+ expect(listener).toHaveBeenLastCalledWith({
84
+ ...payload,
85
+ event: DEVICE.CONNECT,
86
+ type: DEVICE.CONNECT,
87
+ });
88
+ const message = { event: UI_EVENT, type: UI_REQUEST.REQUEST_BUTTON, payload: {} };
89
+ core.emit(CORE_EVENT, message);
90
+ expect(listener).toHaveBeenLastCalledWith(message);
91
+ await HardwareSDKLowLevel.dispose();
92
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
93
+ listener.mockClear();
94
+ core.emit(CORE_EVENT, message);
95
+ expect(listener).not.toHaveBeenCalled();
96
+ expect(core.listenerCount(CORE_EVENT)).toBe(1);
97
+ });
98
+
99
+ test('uses settings staged before initialization', async () => {
100
+ await HardwareSDKLowLevel.updateSettings({ env: 'webusb' });
101
+ await HardwareSDKLowLevel.init({ debug: false });
102
+ expect(initCore).toHaveBeenCalledWith(
103
+ expect.objectContaining({ env: 'webusb' }),
104
+ expect.anything(),
105
+ undefined,
106
+ expect.any(AbortSignal)
107
+ );
108
+ });
109
+
110
+ test('reports settings errors through the Promise contract', async () => {
111
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
112
+ const result = HardwareSDKLowLevel.updateSettings({});
113
+ await expect(result).rejects.toMatchObject({
114
+ errorCode: HardwareErrorCode.IFrameAleradyInitialized,
115
+ });
116
+ });
117
+
118
+ test('rejects settings updates as soon as initialization is queued', async () => {
119
+ const initializing = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: true });
120
+
121
+ await expect(
122
+ HardwareSDKLowLevel.updateSettings({ firmwareManifestMode: 'external-only' })
123
+ ).rejects.toMatchObject({ errorCode: HardwareErrorCode.IFrameAleradyInitialized });
124
+
125
+ await expect(initializing).resolves.toBe(true);
126
+ });
127
+
128
+ test.each([
129
+ UI_REQUEST.FIRMWARE_PROGRESS,
130
+ UI_REQUEST.FIRMWARE_TIP,
131
+ UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
132
+ ])('forwards %s once with the original UI envelope', async type => {
133
+ const listener = jest.fn();
134
+ HardwareSDKLowLevel.addHardwareGlobalEventListener(listener);
135
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
136
+ const message = { event: UI_EVENT, type, payload: { progress: 1 } };
137
+ core.emit(CORE_EVENT, message);
138
+ expect(listener).toHaveBeenCalledTimes(1);
139
+ expect(listener).toHaveBeenCalledWith(message);
140
+ });
141
+
142
+ test('waits for an in-flight initialization to release its Core on dispose', async () => {
143
+ const entered = createDeferred();
144
+ const initializingCore = createDeferred();
145
+ const cleanupStarted = createDeferred();
146
+ const cleanupFinished = createDeferred();
147
+ initCore.mockImplementationOnce(() => {
148
+ entered.resolve();
149
+ return initializingCore.promise;
150
+ });
151
+ core.dispose.mockImplementationOnce(() => {
152
+ cleanupStarted.resolve();
153
+ return cleanupFinished.promise;
154
+ });
155
+ const initializing = HardwareSDKLowLevel.init({ env: 'webusb' });
156
+ await entered.promise;
157
+ const disposing = HardwareSDKLowLevel.dispose();
158
+ const settled = jest.fn();
159
+ const completion = disposing.then(settled);
160
+ initializingCore.resolve(core);
161
+ try {
162
+ await Promise.race([cleanupStarted.promise, disposing]);
163
+ expect(settled).not.toHaveBeenCalled();
164
+ } finally {
165
+ cleanupFinished.resolve();
166
+ }
167
+ await completion;
168
+ expect(await initializing).toBe(false);
169
+ expect(core.dispose).toHaveBeenCalledTimes(1);
170
+ expect(core.listenerCount(CORE_EVENT)).toBe(0);
171
+ });
172
+
173
+ test('cancels initialization on disposal and lets the next initialization proceed', async () => {
174
+ const started = createDeferred();
175
+ initCore.mockImplementationOnce((_settings, _transport, _plugin, signal) => {
176
+ started.resolve();
177
+ return new Promise(resolve => {
178
+ signal.addEventListener('abort', () => resolve(undefined), { once: true });
179
+ });
180
+ });
181
+
182
+ const abandoned = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: true });
183
+ await started.promise;
184
+ const disposing = HardwareSDKLowLevel.dispose();
185
+ const restarted = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: false });
186
+
187
+ await expect(disposing).resolves.toBeUndefined();
188
+ await expect(abandoned).resolves.toBe(false);
189
+ await expect(restarted).resolves.toBe(true);
190
+ expect(core.listenerCount(CORE_EVENT)).toBe(1);
191
+ });
192
+
193
+ test('binds the switch to its Core before waiting for the transport', async () => {
194
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
195
+ const switching = HardwareSDKLowLevel.switchTransport('webusb');
196
+ expect(switchTransport).toHaveBeenCalledWith({
197
+ env: 'webusb',
198
+ owner: core,
199
+ loadTransport: expect.any(Function),
200
+ plugin: undefined,
201
+ });
202
+ await switching;
203
+ });
204
+
205
+ test('preserves PIN and passphrase response correlation through the real Common adapter', async () => {
206
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
207
+ core.handleMessage.mockResolvedValue(undefined);
208
+ for (const type of [UI_RESPONSE.RECEIVE_PIN, UI_RESPONSE.RECEIVE_PASSPHRASE]) {
209
+ const response = {
210
+ type,
211
+ payload: type === UI_RESPONSE.RECEIVE_PIN ? '' : { value: '', passphraseOnDevice: true },
212
+ interactionId: 'synthetic-interaction',
213
+ deviceId: 'synthetic-device',
214
+ };
215
+ HardwareSDKLowLevel.uiResponse(response);
216
+ expect(core.handleMessage).toHaveBeenLastCalledWith({ ...response, event: UI_EVENT });
217
+ }
218
+ });
219
+
220
+ test('transport switching waits for completion and propagates rejection', async () => {
221
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
222
+ let finish;
223
+ switchTransport.mockReturnValueOnce(
224
+ new Promise(resolve => {
225
+ finish = resolve;
226
+ })
227
+ );
228
+ const settled = jest.fn();
229
+ const switching = HardwareSDKLowLevel.switchTransport('webusb').then(settled);
230
+ await Promise.resolve();
231
+ await Promise.resolve();
232
+ expect(settled).not.toHaveBeenCalled();
233
+ finish();
234
+ await switching;
235
+ expect(settled).toHaveBeenCalledWith({ success: true, payload: {} });
236
+ const failure = new Error('synthetic switch failure');
237
+ switchTransport.mockRejectedValueOnce(failure);
238
+ await expect(HardwareSDKLowLevel.switchTransport('webusb')).rejects.toBe(failure);
239
+ });
240
+
241
+ test('rejects unsupported react-native transport in Common SDK', async () => {
242
+ await HardwareSDKLowLevel.init({ env: 'webusb' });
243
+ switchTransport.mockImplementationOnce(async ({ loadTransport }) => {
244
+ await loadTransport();
245
+ });
246
+ await expect(HardwareSDKLowLevel.switchTransport('react-native')).rejects.toMatchObject({
247
+ errorCode: HardwareErrorCode.TransportNotConfigured,
248
+ });
249
+ });
package/dist/index.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
2
- import { UsbDeviceIdentity } from '@onekeyfe/hd-core';
2
+ import { UsbDeviceIdentity, LowLevelCoreApi } from '@onekeyfe/hd-core';
3
3
  import { Deferred } from '@onekeyfe/hd-shared';
4
4
 
5
5
  /** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
@@ -9,6 +9,7 @@ declare const probeUsbDeviceIdentities: ({ commType, }: {
9
9
  declare const messagePromises: {
10
10
  [key: number]: Deferred<any>;
11
11
  };
12
+ declare const HardwareSDKLowLevel: LowLevelCoreApi;
12
13
  declare const HardwareCommonConnectSdk: _onekeyfe_hd_core.CoreApi;
13
14
 
14
- export { HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
15
+ export { HardwareSDKLowLevel, HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
package/dist/index.js CHANGED
@@ -586,6 +586,9 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
586
586
  return __generator(this, function (_a) {
587
587
  switch (_a.label) {
588
588
  case 0:
589
+ if (env === 'react-native') {
590
+ throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'React Native transport is not supported by @onekeyfe/hd-common-connect-sdk');
591
+ }
589
592
  if (env === 'desktop-web-ble') {
590
593
  return [2 /*return*/, hdTransportWebDevice.ElectronBleTransport];
591
594
  }
@@ -597,6 +600,10 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
597
600
  return [4 /*yield*/, Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@onekeyfe/hd-transport-usb')); })];
598
601
  case 1:
599
602
  NodeUsbTransport = (_a.sent()).default;
603
+ // Browser bundlers replace this Node-only package with an empty module.
604
+ if (typeof NodeUsbTransport !== 'function') {
605
+ throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Node USB requires Node.js');
606
+ }
600
607
  return [2 /*return*/, NodeUsbTransport];
601
608
  case 2:
602
609
  if (env === 'emulator')
@@ -606,7 +613,10 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
606
613
  });
607
614
  }); };
608
615
  var _core;
616
+ var _plugin;
609
617
  var _settings = HardwareSdk.parseConnectSettings();
618
+ var lifecycle = Promise.resolve(undefined);
619
+ var pendingInitializations = new Set();
610
620
  var usbIdentityProbeTransports = {};
611
621
  var usbIdentityProbes = {};
612
622
  /** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
@@ -634,21 +644,26 @@ var probeUsbDeviceIdentities = function (_a) {
634
644
  var _messageID = 0;
635
645
  var messagePromises = {};
636
646
  var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
637
- var core;
638
- var _a;
639
- return __generator(this, function (_b) {
640
- switch (_b.label) {
647
+ var core, pending, disposing;
648
+ return __generator(this, function (_a) {
649
+ switch (_a.label) {
641
650
  case 0:
642
651
  core = _core;
652
+ pendingInitializations.forEach(function (controller) { return controller.abort(); });
653
+ pendingInitializations.clear();
654
+ pending = lifecycle.catch(function () { return undefined; });
643
655
  _core = undefined;
656
+ _plugin = undefined;
644
657
  eventEmitter.removeAllListeners();
645
658
  Object.keys(messagePromises).forEach(function (key) {
646
659
  delete messagePromises[Number(key)];
647
660
  });
648
661
  _settings = HardwareSdk.parseConnectSettings();
649
- return [4 /*yield*/, ((_a = core === null || core === void 0 ? void 0 : core.dispose) === null || _a === void 0 ? void 0 : _a.call(core))];
662
+ disposing = Promise.all([pending, core === null || core === void 0 ? void 0 : core.dispose()]);
663
+ lifecycle = disposing;
664
+ return [4 /*yield*/, disposing];
650
665
  case 1:
651
- _b.sent();
666
+ _a.sent();
652
667
  return [2 /*return*/];
653
668
  }
654
669
  });
@@ -657,13 +672,16 @@ var uiResponse = function (response) {
657
672
  if (!_core) {
658
673
  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
659
674
  }
660
- var type = response.type, payload = response.payload;
661
- _core.handleMessage({ event: HardwareSdk.UI_EVENT, type: type, payload: payload });
675
+ _core
676
+ .handleMessage(__assign(__assign({}, response), { event: HardwareSdk.UI_EVENT }))
677
+ .catch(function (error) { return Log.error(HardwareSdk.createErrorMessage(error)); });
662
678
  };
663
679
  var cancel = function (connectId) {
664
680
  if (_core === undefined)
665
681
  return;
666
- _core.handleMessage({ event: HardwareSdk.IFRAME.CANCEL, type: HardwareSdk.IFRAME.CANCEL, payload: { connectId: connectId } });
682
+ _core
683
+ .handleMessage({ event: HardwareSdk.IFRAME.CANCEL, type: HardwareSdk.IFRAME.CANCEL, payload: { connectId: connectId } })
684
+ .catch(function (error) { return Log.debug('cancel error: ', error); });
667
685
  };
668
686
  function handleMessage(message) {
669
687
  var event = message.event;
@@ -729,37 +747,73 @@ function postMessage(message, usePromise) {
729
747
  });
730
748
  });
731
749
  }
732
- var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, void 0, function () {
733
- var Transport, error_1;
750
+ var init = function (settings, _, plugin) {
734
751
  var _a;
735
- return __generator(this, function (_b) {
736
- switch (_b.label) {
737
- case 0:
738
- _settings = __assign(__assign(__assign({}, _settings), settings), { env: (_a = settings.env) !== null && _a !== void 0 ? _a : 'node' });
739
- HardwareSdk.enableLog(!!settings.debug);
740
- Log.debug('init');
741
- _b.label = 1;
742
- case 1:
743
- _b.trys.push([1, 4, , 5]);
744
- return [4 /*yield*/, getTransport(_settings.env)];
745
- case 2:
746
- Transport = _b.sent();
747
- return [4 /*yield*/, HardwareSdk.initCore(_settings, Transport, plugin)];
748
- case 3:
749
- _core = _b.sent();
750
- _core === null || _core === void 0 ? void 0 : _core.on(HardwareSdk.CORE_EVENT, handleMessage);
751
- HardwareSdk.setLoggerPostMessage(handleMessage);
752
- return [2 /*return*/, true];
753
- case 4:
754
- error_1 = _b.sent();
755
- Log.error(HardwareSdk.createErrorMessage(error_1));
756
- return [2 /*return*/, false];
757
- case 5: return [2 /*return*/];
758
- }
752
+ _settings = __assign(__assign(__assign({}, _settings), settings), { env: (_a = settings.env) !== null && _a !== void 0 ? _a : 'node' });
753
+ var initSettings = _settings;
754
+ var controller = new AbortController();
755
+ var signal = controller.signal;
756
+ pendingInitializations.add(controller);
757
+ var initialize = function () { return __awaiter(void 0, void 0, void 0, function () {
758
+ var Transport, previous, core, error_1;
759
+ return __generator(this, function (_a) {
760
+ switch (_a.label) {
761
+ case 0:
762
+ if (signal.aborted)
763
+ return [2 /*return*/, false];
764
+ HardwareSdk.enableLog(!!settings.debug);
765
+ Log.debug('init');
766
+ _a.label = 1;
767
+ case 1:
768
+ _a.trys.push([1, 8, , 9]);
769
+ return [4 /*yield*/, getTransport(initSettings.env)];
770
+ case 2:
771
+ Transport = _a.sent();
772
+ if (signal.aborted)
773
+ return [2 /*return*/, false];
774
+ previous = _core;
775
+ _core = undefined;
776
+ _plugin = undefined;
777
+ if (!previous) return [3 /*break*/, 4];
778
+ return [4 /*yield*/, previous.dispose()];
779
+ case 3:
780
+ _a.sent();
781
+ _a.label = 4;
782
+ case 4:
783
+ if (signal.aborted)
784
+ return [2 /*return*/, false];
785
+ return [4 /*yield*/, HardwareSdk.initCore(initSettings, Transport, plugin, signal)];
786
+ case 5:
787
+ core = _a.sent();
788
+ if (!core)
789
+ return [2 /*return*/, false];
790
+ if (!signal.aborted) return [3 /*break*/, 7];
791
+ return [4 /*yield*/, core.dispose()];
792
+ case 6:
793
+ _a.sent();
794
+ return [2 /*return*/, false];
795
+ case 7:
796
+ _core = core;
797
+ _plugin = plugin;
798
+ core.on(HardwareSdk.CORE_EVENT, handleMessage);
799
+ HardwareSdk.setLoggerPostMessage(handleMessage);
800
+ return [2 /*return*/, true];
801
+ case 8:
802
+ error_1 = _a.sent();
803
+ Log.error(HardwareSdk.createErrorMessage(error_1));
804
+ return [2 /*return*/, false];
805
+ case 9: return [2 /*return*/];
806
+ }
807
+ });
808
+ }); };
809
+ var initializing = lifecycle.then(initialize, initialize).finally(function () {
810
+ pendingInitializations.delete(controller);
759
811
  });
760
- }); };
812
+ lifecycle = initializing;
813
+ return initializing;
814
+ };
761
815
  var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
762
- var blockLog, response, error_2;
816
+ var blockLog, response, emitBleUiWarning, error_2;
763
817
  var _a, _b, _c, _d;
764
818
  return __generator(this, function (_e) {
765
819
  switch (_e.label) {
@@ -775,17 +829,22 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
775
829
  if (response) {
776
830
  Log.debug('response: ', blockLog ? '[REDACTED]' : response);
777
831
  if (!response.success) {
832
+ emitBleUiWarning = function (message) {
833
+ postMessage(message, false).catch(function (error) {
834
+ return Log.debug('postMessage warning error: ', error);
835
+ });
836
+ };
778
837
  if (((_a = response.payload) === null || _a === void 0 ? void 0 : _a.code) === hdShared.HardwareErrorCode.BleUnsupported) {
779
- postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_UNSUPPORTED), false);
838
+ emitBleUiWarning(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_UNSUPPORTED));
780
839
  }
781
840
  if (((_b = response.payload) === null || _b === void 0 ? void 0 : _b.code) === hdShared.HardwareErrorCode.BlePoweredOff) {
782
- postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_POWERED_OFF), false);
841
+ emitBleUiWarning(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_POWERED_OFF));
783
842
  }
784
843
  if (((_c = response.payload) === null || _c === void 0 ? void 0 : _c.code) === hdShared.HardwareErrorCode.BlePermissionError) {
785
- postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_PERMISSION), false);
844
+ emitBleUiWarning(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_PERMISSION));
786
845
  }
787
846
  if (((_d = response.payload) === null || _d === void 0 ? void 0 : _d.code) === hdShared.HardwareErrorCode.BleLocationError) {
788
- postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.LOCATION_PERMISSION), false);
847
+ emitBleUiWarning(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.LOCATION_PERMISSION));
789
848
  }
790
849
  }
791
850
  return [2 /*return*/, response];
@@ -801,6 +860,65 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
801
860
  }); };
802
861
  var updateSettings = function () { return Promise.resolve(true); };
803
862
  var switchTransport = function () { return Promise.resolve({ success: true }); };
863
+ var addHardwareGlobalEventListener = function (listener) {
864
+ [
865
+ HardwareSdk.UI_EVENT,
866
+ HardwareSdk.LOG_EVENT,
867
+ HardwareSdk.FIRMWARE_EVENT,
868
+ HardwareSdk.DEVICE.CONNECT,
869
+ HardwareSdk.DEVICE.DISCONNECT,
870
+ HardwareSdk.DEVICE.FEATURES,
871
+ HardwareSdk.DEVICE.STATE,
872
+ HardwareSdk.DEVICE.SUPPORT_FEATURES,
873
+ ].forEach(function (eventName) {
874
+ eventEmitter.on(eventName, function (message) {
875
+ // Match the Web SDK envelope for device events emitted as payloads.
876
+ var envelope = message;
877
+ var emitMessage = message;
878
+ if (envelope && typeof envelope === 'object' && !envelope.event && !envelope.type) {
879
+ emitMessage = __assign({}, message);
880
+ Object.assign(emitMessage, { event: eventName, type: eventName });
881
+ }
882
+ listener(emitMessage);
883
+ });
884
+ });
885
+ };
886
+ var HardwareSDKLowLevel = HardwareSdk.HardwareSDKLowLevel({
887
+ eventEmitter: eventEmitter,
888
+ init: function (settings, sdk, plugin) { return init(__assign(__assign({}, _settings), settings), sdk, plugin); },
889
+ call: call,
890
+ cancel: cancel,
891
+ dispose: dispose,
892
+ addHardwareGlobalEventListener: addHardwareGlobalEventListener,
893
+ uiResponse: uiResponse,
894
+ updateSettings: function (settings) {
895
+ if (_core || pendingInitializations.size > 0) {
896
+ return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.IFrameAleradyInitialized));
897
+ }
898
+ _settings = HardwareSdk.parseConnectSettings(__assign(__assign({}, _settings), settings));
899
+ return Promise.resolve(true);
900
+ },
901
+ switchTransport: function (env) { return __awaiter(void 0, void 0, void 0, function () {
902
+ var owner;
903
+ return __generator(this, function (_a) {
904
+ switch (_a.label) {
905
+ case 0:
906
+ owner = _core;
907
+ if (!owner)
908
+ throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
909
+ return [4 /*yield*/, HardwareSdk.switchTransport({
910
+ env: env,
911
+ owner: owner,
912
+ loadTransport: function () { return getTransport(env); },
913
+ plugin: _plugin,
914
+ })];
915
+ case 1:
916
+ _a.sent();
917
+ return [2 /*return*/, { success: true, payload: {} }];
918
+ }
919
+ });
920
+ }); },
921
+ });
804
922
  var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
805
923
  eventEmitter: eventEmitter,
806
924
  init: init,
@@ -812,6 +930,7 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
812
930
  switchTransport: switchTransport,
813
931
  });
814
932
 
933
+ exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
815
934
  exports["default"] = HardwareCommonConnectSdk;
816
935
  exports.messagePromises = messagePromises;
817
936
  exports.probeUsbDeviceIdentities = probeUsbDeviceIdentities;
package/package.json CHANGED
@@ -1,10 +1,13 @@
1
1
  {
2
2
  "name": "@onekeyfe/hd-common-connect-sdk",
3
- "version": "1.2.11-alpha.8",
3
+ "version": "1.2.11-alpha.9",
4
4
  "author": "OneKey",
5
5
  "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
6
6
  "license": "ISC",
7
7
  "main": "dist/index.js",
8
+ "browser": {
9
+ "@onekeyfe/hd-transport-usb": false
10
+ },
8
11
  "types": "dist/index.d.ts",
9
12
  "repository": {
10
13
  "type": "git",
@@ -15,19 +18,23 @@
15
18
  },
16
19
  "scripts": {
17
20
  "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
18
- "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
21
+ "build": "rimraf dist && rollup -c ../../build/rollup.config.js && node scripts/check-bundle.mjs",
19
22
  "test": "jest",
20
23
  "lint": "eslint .",
21
24
  "lint:fix": "eslint . --fix"
22
25
  },
26
+ "devDependencies": {
27
+ "esbuild": "^0.27.0"
28
+ },
23
29
  "dependencies": {
24
- "@onekeyfe/hd-core": "1.2.11-alpha.8",
25
- "@onekeyfe/hd-shared": "1.2.11-alpha.8",
26
- "@onekeyfe/hd-transport-emulator": "1.2.11-alpha.8",
27
- "@onekeyfe/hd-transport-http": "1.2.11-alpha.8",
28
- "@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.8",
29
- "@onekeyfe/hd-transport-usb": "1.2.11-alpha.8",
30
- "@onekeyfe/hd-transport-web-device": "1.2.11-alpha.8"
30
+ "@onekeyfe/hd-core": "1.2.11-alpha.9",
31
+ "@onekeyfe/hd-shared": "1.2.11-alpha.9",
32
+ "@onekeyfe/hd-transport-emulator": "1.2.11-alpha.9",
33
+ "@onekeyfe/hd-transport-http": "1.2.11-alpha.9",
34
+ "@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.9",
35
+ "@onekeyfe/hd-transport-usb": "1.2.11-alpha.9",
36
+ "@onekeyfe/hd-transport-web-device": "1.2.11-alpha.9",
37
+ "events": "^3.3.0"
31
38
  },
32
- "gitHead": "f2f0e4af13efbb09f4b421171142f9144124a1c2"
39
+ "gitHead": "42a772503abc1acb973bc31232a4c30f113034d1"
33
40
  }
@@ -0,0 +1,35 @@
1
+ import assert from 'node:assert/strict';
2
+ import { fileURLToPath } from 'node:url';
3
+
4
+ import { buildSync } from 'esbuild';
5
+
6
+ const packageDirectory = fileURLToPath(new URL('..', import.meta.url));
7
+ const options = {
8
+ absWorkingDir: packageDirectory,
9
+ stdin: {
10
+ contents: `export { HardwareSDKLowLevel } from '@onekeyfe/hd-common-connect-sdk';`,
11
+ resolveDir: packageDirectory,
12
+ },
13
+ bundle: true,
14
+ format: 'cjs',
15
+ logLevel: 'error',
16
+ metafile: true,
17
+ write: false,
18
+ };
19
+
20
+ const nativeUsbModule = /(?:^|\/)(?:hd-transport-usb|usb|node-gyp-build)\//u;
21
+ const hasNativeUsb = ({ metafile }) =>
22
+ Object.keys(metafile.inputs).some(
23
+ input => !input.startsWith('(disabled):') && nativeUsbModule.test(input)
24
+ );
25
+
26
+ assert.equal(
27
+ hasNativeUsb(buildSync({ ...options, platform: 'browser' })),
28
+ false,
29
+ 'Browser bundles must exclude the native USB transport'
30
+ );
31
+ assert.equal(
32
+ hasNativeUsb(buildSync({ ...options, platform: 'node' })),
33
+ true,
34
+ 'Node bundles must retain the native USB transport'
35
+ );
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,
@@ -19,6 +20,7 @@ import HardwareSdk, {
19
20
  parseConnectSettings,
20
21
  probeUsbDeviceIdentitiesWithTransport,
21
22
  setLoggerPostMessage,
23
+ switchTransport as switchCoreTransport,
22
24
  } from '@onekeyfe/hd-core';
23
25
  import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
24
26
  import HttpTransport from '@onekeyfe/hd-transport-http';
@@ -41,15 +43,26 @@ const eventEmitter = new EventEmitter();
41
43
  const Log = getLogger(LoggerNames.HdCommonConnectSdk);
42
44
 
43
45
  const getTransport = async (env: ConnectSettings['env']) => {
46
+ if (env === 'react-native') {
47
+ throw ERRORS.TypedError(
48
+ HardwareErrorCode.TransportNotConfigured,
49
+ 'React Native transport is not supported by @onekeyfe/hd-common-connect-sdk'
50
+ );
51
+ }
44
52
  if (env === 'desktop-web-ble') {
45
53
  return ElectronBleTransport;
46
54
  }
47
55
  if (env === 'webusb' || env === 'desktop-webusb') return WebUsbTransport;
48
56
  if (env === 'lowlevel') return LowlevelTransport;
49
57
  if (env === 'node-usb') {
50
- // Dynamic import — usb is a native Node.js module (libusb C++ bindings)
51
- // that cannot be resolved by browser/React Native bundlers
52
58
  const { default: NodeUsbTransport } = await import('@onekeyfe/hd-transport-usb');
59
+ // Browser bundlers replace this Node-only package with an empty module.
60
+ if (typeof NodeUsbTransport !== 'function') {
61
+ throw ERRORS.TypedError(
62
+ HardwareErrorCode.TransportNotConfigured,
63
+ 'Node USB requires Node.js'
64
+ );
65
+ }
53
66
  return NodeUsbTransport;
54
67
  }
55
68
  if (env === 'emulator') return EmulatorTransport;
@@ -57,7 +70,10 @@ const getTransport = async (env: ConnectSettings['env']) => {
57
70
  };
58
71
 
59
72
  let _core: Core | undefined;
73
+ let _plugin: LowlevelTransportSharedPlugin | undefined;
60
74
  let _settings = parseConnectSettings();
75
+ let lifecycle = Promise.resolve<unknown>(undefined);
76
+ const pendingInitializations = new Set<AbortController>();
61
77
 
62
78
  const usbIdentityProbeTransports: Partial<Record<UsbDeviceIdentity['commType'], WebUsbTransport>> =
63
79
  {};
@@ -95,26 +111,35 @@ export const messagePromises: { [key: number]: Deferred<any> } = {};
95
111
 
96
112
  const dispose = async () => {
97
113
  const core = _core;
114
+ pendingInitializations.forEach(controller => controller.abort());
115
+ pendingInitializations.clear();
116
+ const pending = lifecycle.catch(() => undefined);
98
117
  _core = undefined;
118
+ _plugin = undefined;
99
119
  eventEmitter.removeAllListeners();
100
120
  Object.keys(messagePromises).forEach(key => {
101
121
  delete messagePromises[Number(key)];
102
122
  });
103
123
  _settings = parseConnectSettings();
104
- await core?.dispose?.();
124
+ const disposing = Promise.all([pending, core?.dispose()]);
125
+ lifecycle = disposing;
126
+ await disposing;
105
127
  };
106
128
 
107
129
  const uiResponse = (response: UiResponseEvent) => {
108
130
  if (!_core) {
109
131
  throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
110
132
  }
111
- const { type, payload } = response;
112
- _core.handleMessage({ event: UI_EVENT, type, payload } as CoreMessage);
133
+ _core
134
+ .handleMessage({ ...response, event: UI_EVENT } as CoreMessage)
135
+ .catch(error => Log.error(createErrorMessage(error)));
113
136
  };
114
137
 
115
138
  const cancel = (connectId?: string) => {
116
139
  if (_core === undefined) return;
117
- _core.handleMessage({ event: IFRAME.CANCEL, type: IFRAME.CANCEL, payload: { connectId } });
140
+ _core
141
+ .handleMessage({ event: IFRAME.CANCEL, type: IFRAME.CANCEL, payload: { connectId } })
142
+ .catch(error => Log.debug('cancel error: ', error));
118
143
  };
119
144
 
120
145
  function handleMessage(message: CoreMessage) {
@@ -177,29 +202,53 @@ async function postMessage(message: CoreMessage, usePromise = true) {
177
202
  _core.handleMessage(message);
178
203
  }
179
204
 
180
- const init = async (
205
+ const init = (
181
206
  settings: Partial<ConnectSettings>,
182
207
  _?: LowLevelCoreApi,
183
208
  plugin?: LowlevelTransportSharedPlugin
184
209
  ) => {
185
210
  _settings = { ..._settings, ...settings, env: settings.env ?? 'node' };
211
+ const initSettings = _settings;
212
+ const controller = new AbortController();
213
+ const { signal } = controller;
214
+ pendingInitializations.add(controller);
186
215
 
187
- enableLog(!!settings.debug);
188
-
189
- Log.debug('init');
216
+ const initialize = async () => {
217
+ if (signal.aborted) return false;
218
+ enableLog(!!settings.debug);
219
+ Log.debug('init');
190
220
 
191
- try {
192
- const Transport = await getTransport(_settings.env);
193
- _core = await initCore(_settings, Transport, plugin);
194
- _core?.on(CORE_EVENT, handleMessage);
195
- setLoggerPostMessage(handleMessage);
221
+ try {
222
+ const Transport = await getTransport(initSettings.env);
223
+ if (signal.aborted) return false;
196
224
 
197
- return true;
198
- } catch (error) {
199
- Log.error(createErrorMessage(error));
225
+ const previous = _core;
226
+ _core = undefined;
227
+ _plugin = undefined;
228
+ if (previous) await previous.dispose();
229
+ if (signal.aborted) return false;
230
+ const core = await initCore(initSettings, Transport, plugin, signal);
231
+ if (!core) return false;
232
+ if (signal.aborted) {
233
+ await core.dispose();
234
+ return false;
235
+ }
236
+ _core = core;
237
+ _plugin = plugin;
238
+ core.on(CORE_EVENT, handleMessage);
239
+ setLoggerPostMessage(handleMessage);
240
+ return true;
241
+ } catch (error) {
242
+ Log.error(createErrorMessage(error));
243
+ return false;
244
+ }
245
+ };
200
246
 
201
- return false;
202
- }
247
+ const initializing = lifecycle.then(initialize, initialize).finally(() => {
248
+ pendingInitializations.delete(controller);
249
+ });
250
+ lifecycle = initializing;
251
+ return initializing;
203
252
  };
204
253
 
205
254
  const call = async (params: any) => {
@@ -212,17 +261,22 @@ const call = async (params: any) => {
212
261
  Log.debug('response: ', blockLog ? '[REDACTED]' : response);
213
262
 
214
263
  if (!response.success) {
264
+ const emitBleUiWarning = (message: CoreMessage) => {
265
+ postMessage(message, false).catch(error =>
266
+ Log.debug('postMessage warning error: ', error)
267
+ );
268
+ };
215
269
  if (response.payload?.code === HardwareErrorCode.BleUnsupported) {
216
- postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_UNSUPPORTED), false);
270
+ emitBleUiWarning(createUiMessage(UI_REQUEST.BLUETOOTH_UNSUPPORTED));
217
271
  }
218
272
  if (response.payload?.code === HardwareErrorCode.BlePoweredOff) {
219
- postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_POWERED_OFF), false);
273
+ emitBleUiWarning(createUiMessage(UI_REQUEST.BLUETOOTH_POWERED_OFF));
220
274
  }
221
275
  if (response.payload?.code === HardwareErrorCode.BlePermissionError) {
222
- postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_PERMISSION), false);
276
+ emitBleUiWarning(createUiMessage(UI_REQUEST.BLUETOOTH_PERMISSION));
223
277
  }
224
278
  if (response.payload?.code === HardwareErrorCode.BleLocationError) {
225
- postMessage(createUiMessage(UI_REQUEST.LOCATION_PERMISSION), false);
279
+ emitBleUiWarning(createUiMessage(UI_REQUEST.LOCATION_PERMISSION));
226
280
  }
227
281
  }
228
282
 
@@ -239,6 +293,58 @@ const call = async (params: any) => {
239
293
  const updateSettings = () => Promise.resolve(true);
240
294
  const switchTransport = () => Promise.resolve({ success: true });
241
295
 
296
+ const addHardwareGlobalEventListener = (listener: (message: CoreMessage) => void) => {
297
+ [
298
+ UI_EVENT,
299
+ LOG_EVENT,
300
+ FIRMWARE_EVENT,
301
+ DEVICE.CONNECT,
302
+ DEVICE.DISCONNECT,
303
+ DEVICE.FEATURES,
304
+ DEVICE.STATE,
305
+ DEVICE.SUPPORT_FEATURES,
306
+ ].forEach(eventName => {
307
+ eventEmitter.on(eventName, (message: CoreMessage) => {
308
+ // Match the Web SDK envelope for device events emitted as payloads.
309
+ const envelope = message as { event?: string; type?: string } | null | undefined;
310
+ let emitMessage = message;
311
+ if (envelope && typeof envelope === 'object' && !envelope.event && !envelope.type) {
312
+ emitMessage = { ...message };
313
+ Object.assign(emitMessage, { event: eventName, type: eventName });
314
+ }
315
+ listener(emitMessage);
316
+ });
317
+ });
318
+ };
319
+
320
+ export const HardwareSDKLowLevel = HardwareLowLevelSdk({
321
+ eventEmitter,
322
+ init: (settings, sdk, plugin) => init({ ..._settings, ...settings }, sdk, plugin),
323
+ call,
324
+ cancel,
325
+ dispose,
326
+ addHardwareGlobalEventListener,
327
+ uiResponse,
328
+ updateSettings: (settings: Partial<ConnectSettings>) => {
329
+ if (_core || pendingInitializations.size > 0) {
330
+ return Promise.reject(ERRORS.TypedError(HardwareErrorCode.IFrameAleradyInitialized));
331
+ }
332
+ _settings = parseConnectSettings({ ..._settings, ...settings });
333
+ return Promise.resolve(true);
334
+ },
335
+ switchTransport: async (env: ConnectSettings['env']) => {
336
+ const owner = _core;
337
+ if (!owner) throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
338
+ await switchCoreTransport({
339
+ env,
340
+ owner,
341
+ loadTransport: () => getTransport(env),
342
+ plugin: _plugin,
343
+ });
344
+ return { success: true, payload: {} };
345
+ },
346
+ });
347
+
242
348
  const HardwareCommonConnectSdk = HardwareSdk({
243
349
  eventEmitter,
244
350
  init,