@onekeyfe/hd-common-connect-sdk 1.2.11-alpha.4 → 1.2.11-alpha.6

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,239 @@
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
+ });
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
@@ -597,6 +597,10 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
597
597
  return [4 /*yield*/, Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@onekeyfe/hd-transport-usb')); })];
598
598
  case 1:
599
599
  NodeUsbTransport = (_a.sent()).default;
600
+ // Browser bundlers replace this Node-only package with an empty module.
601
+ if (typeof NodeUsbTransport !== 'function') {
602
+ throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Node USB requires Node.js');
603
+ }
600
604
  return [2 /*return*/, NodeUsbTransport];
601
605
  case 2:
602
606
  if (env === 'emulator')
@@ -606,7 +610,10 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
606
610
  });
607
611
  }); };
608
612
  var _core;
613
+ var _plugin;
609
614
  var _settings = HardwareSdk.parseConnectSettings();
615
+ var lifecycle = Promise.resolve(undefined);
616
+ var pendingInitializations = new Set();
610
617
  var usbIdentityProbeTransports = {};
611
618
  var usbIdentityProbes = {};
612
619
  /** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
@@ -634,21 +641,26 @@ var probeUsbDeviceIdentities = function (_a) {
634
641
  var _messageID = 0;
635
642
  var messagePromises = {};
636
643
  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) {
644
+ var core, pending, disposing;
645
+ return __generator(this, function (_a) {
646
+ switch (_a.label) {
641
647
  case 0:
642
648
  core = _core;
649
+ pendingInitializations.forEach(function (controller) { return controller.abort(); });
650
+ pendingInitializations.clear();
651
+ pending = lifecycle.catch(function () { return undefined; });
643
652
  _core = undefined;
653
+ _plugin = undefined;
644
654
  eventEmitter.removeAllListeners();
645
655
  Object.keys(messagePromises).forEach(function (key) {
646
656
  delete messagePromises[Number(key)];
647
657
  });
648
658
  _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))];
659
+ disposing = Promise.all([pending, core === null || core === void 0 ? void 0 : core.dispose()]);
660
+ lifecycle = disposing;
661
+ return [4 /*yield*/, disposing];
650
662
  case 1:
651
- _b.sent();
663
+ _a.sent();
652
664
  return [2 /*return*/];
653
665
  }
654
666
  });
@@ -657,8 +669,9 @@ var uiResponse = function (response) {
657
669
  if (!_core) {
658
670
  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
659
671
  }
660
- var type = response.type, payload = response.payload;
661
- _core.handleMessage({ event: HardwareSdk.UI_EVENT, type: type, payload: payload });
672
+ _core
673
+ .handleMessage(__assign(__assign({}, response), { event: HardwareSdk.UI_EVENT }))
674
+ .catch(function (error) { return Log.error(HardwareSdk.createErrorMessage(error)); });
662
675
  };
663
676
  var cancel = function (connectId) {
664
677
  if (_core === undefined)
@@ -729,35 +742,71 @@ function postMessage(message, usePromise) {
729
742
  });
730
743
  });
731
744
  }
732
- var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, void 0, function () {
733
- var Transport, error_1;
745
+ var init = function (settings, _, plugin) {
734
746
  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
- }
747
+ _settings = __assign(__assign(__assign({}, _settings), settings), { env: (_a = settings.env) !== null && _a !== void 0 ? _a : 'node' });
748
+ var initSettings = _settings;
749
+ var controller = new AbortController();
750
+ var signal = controller.signal;
751
+ pendingInitializations.add(controller);
752
+ var initialize = function () { return __awaiter(void 0, void 0, void 0, function () {
753
+ var Transport, previous, core, error_1;
754
+ return __generator(this, function (_a) {
755
+ switch (_a.label) {
756
+ case 0:
757
+ if (signal.aborted)
758
+ return [2 /*return*/, false];
759
+ HardwareSdk.enableLog(!!settings.debug);
760
+ Log.debug('init');
761
+ _a.label = 1;
762
+ case 1:
763
+ _a.trys.push([1, 8, , 9]);
764
+ return [4 /*yield*/, getTransport(initSettings.env)];
765
+ case 2:
766
+ Transport = _a.sent();
767
+ if (signal.aborted)
768
+ return [2 /*return*/, false];
769
+ previous = _core;
770
+ _core = undefined;
771
+ _plugin = undefined;
772
+ if (!previous) return [3 /*break*/, 4];
773
+ return [4 /*yield*/, previous.dispose()];
774
+ case 3:
775
+ _a.sent();
776
+ _a.label = 4;
777
+ case 4:
778
+ if (signal.aborted)
779
+ return [2 /*return*/, false];
780
+ return [4 /*yield*/, HardwareSdk.initCore(initSettings, Transport, plugin, signal)];
781
+ case 5:
782
+ core = _a.sent();
783
+ if (!core)
784
+ return [2 /*return*/, false];
785
+ if (!signal.aborted) return [3 /*break*/, 7];
786
+ return [4 /*yield*/, core.dispose()];
787
+ case 6:
788
+ _a.sent();
789
+ return [2 /*return*/, false];
790
+ case 7:
791
+ _core = core;
792
+ _plugin = plugin;
793
+ core.on(HardwareSdk.CORE_EVENT, handleMessage);
794
+ HardwareSdk.setLoggerPostMessage(handleMessage);
795
+ return [2 /*return*/, true];
796
+ case 8:
797
+ error_1 = _a.sent();
798
+ Log.error(HardwareSdk.createErrorMessage(error_1));
799
+ return [2 /*return*/, false];
800
+ case 9: return [2 /*return*/];
801
+ }
802
+ });
803
+ }); };
804
+ var initializing = lifecycle.then(initialize, initialize).finally(function () {
805
+ pendingInitializations.delete(controller);
759
806
  });
760
- }); };
807
+ lifecycle = initializing;
808
+ return initializing;
809
+ };
761
810
  var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
762
811
  var blockLog, response, error_2;
763
812
  var _a, _b, _c, _d;
@@ -801,6 +850,65 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
801
850
  }); };
802
851
  var updateSettings = function () { return Promise.resolve(true); };
803
852
  var switchTransport = function () { return Promise.resolve({ success: true }); };
853
+ var addHardwareGlobalEventListener = function (listener) {
854
+ [
855
+ HardwareSdk.UI_EVENT,
856
+ HardwareSdk.LOG_EVENT,
857
+ HardwareSdk.FIRMWARE_EVENT,
858
+ HardwareSdk.DEVICE.CONNECT,
859
+ HardwareSdk.DEVICE.DISCONNECT,
860
+ HardwareSdk.DEVICE.FEATURES,
861
+ HardwareSdk.DEVICE.STATE,
862
+ HardwareSdk.DEVICE.SUPPORT_FEATURES,
863
+ ].forEach(function (eventName) {
864
+ eventEmitter.on(eventName, function (message) {
865
+ // Match the Web SDK envelope for device events emitted as payloads.
866
+ var envelope = message;
867
+ var emitMessage = message;
868
+ if (!envelope.event && !envelope.type) {
869
+ emitMessage = __assign({}, message);
870
+ Object.assign(emitMessage, { event: eventName, type: eventName });
871
+ }
872
+ listener(emitMessage);
873
+ });
874
+ });
875
+ };
876
+ var HardwareSDKLowLevel = HardwareSdk.HardwareSDKLowLevel({
877
+ eventEmitter: eventEmitter,
878
+ init: function (settings, sdk, plugin) { return init(__assign(__assign({}, _settings), settings), sdk, plugin); },
879
+ call: call,
880
+ cancel: cancel,
881
+ dispose: dispose,
882
+ addHardwareGlobalEventListener: addHardwareGlobalEventListener,
883
+ uiResponse: uiResponse,
884
+ updateSettings: function (settings) {
885
+ if (_core || pendingInitializations.size > 0) {
886
+ return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.IFrameAleradyInitialized));
887
+ }
888
+ _settings = HardwareSdk.parseConnectSettings(__assign(__assign({}, _settings), settings));
889
+ return Promise.resolve(true);
890
+ },
891
+ switchTransport: function (env) { return __awaiter(void 0, void 0, void 0, function () {
892
+ var owner;
893
+ return __generator(this, function (_a) {
894
+ switch (_a.label) {
895
+ case 0:
896
+ owner = _core;
897
+ if (!owner)
898
+ throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
899
+ return [4 /*yield*/, HardwareSdk.switchTransport({
900
+ env: env,
901
+ owner: owner,
902
+ loadTransport: function () { return getTransport(env); },
903
+ plugin: _plugin,
904
+ })];
905
+ case 1:
906
+ _a.sent();
907
+ return [2 /*return*/, { success: true, payload: {} }];
908
+ }
909
+ });
910
+ }); },
911
+ });
804
912
  var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
805
913
  eventEmitter: eventEmitter,
806
914
  init: init,
@@ -812,6 +920,7 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
812
920
  switchTransport: switchTransport,
813
921
  });
814
922
 
923
+ exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
815
924
  exports["default"] = HardwareCommonConnectSdk;
816
925
  exports.messagePromises = messagePromises;
817
926
  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.4",
3
+ "version": "1.2.11-alpha.6",
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,22 @@
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.4",
25
- "@onekeyfe/hd-shared": "1.2.11-alpha.4",
26
- "@onekeyfe/hd-transport-emulator": "1.2.11-alpha.4",
27
- "@onekeyfe/hd-transport-http": "1.2.11-alpha.4",
28
- "@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.4",
29
- "@onekeyfe/hd-transport-usb": "1.2.11-alpha.4",
30
- "@onekeyfe/hd-transport-web-device": "1.2.11-alpha.4"
30
+ "@onekeyfe/hd-core": "1.2.11-alpha.6",
31
+ "@onekeyfe/hd-shared": "1.2.11-alpha.6",
32
+ "@onekeyfe/hd-transport-emulator": "1.2.11-alpha.6",
33
+ "@onekeyfe/hd-transport-http": "1.2.11-alpha.6",
34
+ "@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.6",
35
+ "@onekeyfe/hd-transport-usb": "1.2.11-alpha.6",
36
+ "@onekeyfe/hd-transport-web-device": "1.2.11-alpha.6"
31
37
  },
32
- "gitHead": "00944d003ec65be39448b546203ad1f76b07a7f1"
38
+ "gitHead": "fe0e726cdb7de7d9889e26af1db227d9bed32369"
33
39
  }
@@ -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';
@@ -47,9 +49,14 @@ const getTransport = async (env: ConnectSettings['env']) => {
47
49
  if (env === 'webusb' || env === 'desktop-webusb') return WebUsbTransport;
48
50
  if (env === 'lowlevel') return LowlevelTransport;
49
51
  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
52
  const { default: NodeUsbTransport } = await import('@onekeyfe/hd-transport-usb');
53
+ // Browser bundlers replace this Node-only package with an empty module.
54
+ if (typeof NodeUsbTransport !== 'function') {
55
+ throw ERRORS.TypedError(
56
+ HardwareErrorCode.TransportNotConfigured,
57
+ 'Node USB requires Node.js'
58
+ );
59
+ }
53
60
  return NodeUsbTransport;
54
61
  }
55
62
  if (env === 'emulator') return EmulatorTransport;
@@ -57,7 +64,10 @@ const getTransport = async (env: ConnectSettings['env']) => {
57
64
  };
58
65
 
59
66
  let _core: Core | undefined;
67
+ let _plugin: LowlevelTransportSharedPlugin | undefined;
60
68
  let _settings = parseConnectSettings();
69
+ let lifecycle = Promise.resolve<unknown>(undefined);
70
+ const pendingInitializations = new Set<AbortController>();
61
71
 
62
72
  const usbIdentityProbeTransports: Partial<Record<UsbDeviceIdentity['commType'], WebUsbTransport>> =
63
73
  {};
@@ -95,21 +105,28 @@ export const messagePromises: { [key: number]: Deferred<any> } = {};
95
105
 
96
106
  const dispose = async () => {
97
107
  const core = _core;
108
+ pendingInitializations.forEach(controller => controller.abort());
109
+ pendingInitializations.clear();
110
+ const pending = lifecycle.catch(() => undefined);
98
111
  _core = undefined;
112
+ _plugin = undefined;
99
113
  eventEmitter.removeAllListeners();
100
114
  Object.keys(messagePromises).forEach(key => {
101
115
  delete messagePromises[Number(key)];
102
116
  });
103
117
  _settings = parseConnectSettings();
104
- await core?.dispose?.();
118
+ const disposing = Promise.all([pending, core?.dispose()]);
119
+ lifecycle = disposing;
120
+ await disposing;
105
121
  };
106
122
 
107
123
  const uiResponse = (response: UiResponseEvent) => {
108
124
  if (!_core) {
109
125
  throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
110
126
  }
111
- const { type, payload } = response;
112
- _core.handleMessage({ event: UI_EVENT, type, payload } as CoreMessage);
127
+ _core
128
+ .handleMessage({ ...response, event: UI_EVENT } as CoreMessage)
129
+ .catch(error => Log.error(createErrorMessage(error)));
113
130
  };
114
131
 
115
132
  const cancel = (connectId?: string) => {
@@ -177,29 +194,53 @@ async function postMessage(message: CoreMessage, usePromise = true) {
177
194
  _core.handleMessage(message);
178
195
  }
179
196
 
180
- const init = async (
197
+ const init = (
181
198
  settings: Partial<ConnectSettings>,
182
199
  _?: LowLevelCoreApi,
183
200
  plugin?: LowlevelTransportSharedPlugin
184
201
  ) => {
185
202
  _settings = { ..._settings, ...settings, env: settings.env ?? 'node' };
203
+ const initSettings = _settings;
204
+ const controller = new AbortController();
205
+ const { signal } = controller;
206
+ pendingInitializations.add(controller);
186
207
 
187
- enableLog(!!settings.debug);
188
-
189
- Log.debug('init');
208
+ const initialize = async () => {
209
+ if (signal.aborted) return false;
210
+ enableLog(!!settings.debug);
211
+ Log.debug('init');
190
212
 
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);
213
+ try {
214
+ const Transport = await getTransport(initSettings.env);
215
+ if (signal.aborted) return false;
196
216
 
197
- return true;
198
- } catch (error) {
199
- Log.error(createErrorMessage(error));
217
+ const previous = _core;
218
+ _core = undefined;
219
+ _plugin = undefined;
220
+ if (previous) await previous.dispose();
221
+ if (signal.aborted) return false;
222
+ const core = await initCore(initSettings, Transport, plugin, signal);
223
+ if (!core) return false;
224
+ if (signal.aborted) {
225
+ await core.dispose();
226
+ return false;
227
+ }
228
+ _core = core;
229
+ _plugin = plugin;
230
+ core.on(CORE_EVENT, handleMessage);
231
+ setLoggerPostMessage(handleMessage);
232
+ return true;
233
+ } catch (error) {
234
+ Log.error(createErrorMessage(error));
235
+ return false;
236
+ }
237
+ };
200
238
 
201
- return false;
202
- }
239
+ const initializing = lifecycle.then(initialize, initialize).finally(() => {
240
+ pendingInitializations.delete(controller);
241
+ });
242
+ lifecycle = initializing;
243
+ return initializing;
203
244
  };
204
245
 
205
246
  const call = async (params: any) => {
@@ -239,6 +280,58 @@ const call = async (params: any) => {
239
280
  const updateSettings = () => Promise.resolve(true);
240
281
  const switchTransport = () => Promise.resolve({ success: true });
241
282
 
283
+ const addHardwareGlobalEventListener = (listener: (message: CoreMessage) => void) => {
284
+ [
285
+ UI_EVENT,
286
+ LOG_EVENT,
287
+ FIRMWARE_EVENT,
288
+ DEVICE.CONNECT,
289
+ DEVICE.DISCONNECT,
290
+ DEVICE.FEATURES,
291
+ DEVICE.STATE,
292
+ DEVICE.SUPPORT_FEATURES,
293
+ ].forEach(eventName => {
294
+ eventEmitter.on(eventName, (message: CoreMessage) => {
295
+ // Match the Web SDK envelope for device events emitted as payloads.
296
+ const envelope: { event?: string; type?: string } = message;
297
+ let emitMessage = message;
298
+ if (!envelope.event && !envelope.type) {
299
+ emitMessage = { ...message };
300
+ Object.assign(emitMessage, { event: eventName, type: eventName });
301
+ }
302
+ listener(emitMessage);
303
+ });
304
+ });
305
+ };
306
+
307
+ export const HardwareSDKLowLevel = HardwareLowLevelSdk({
308
+ eventEmitter,
309
+ init: (settings, sdk, plugin) => init({ ..._settings, ...settings }, sdk, plugin),
310
+ call,
311
+ cancel,
312
+ dispose,
313
+ addHardwareGlobalEventListener,
314
+ uiResponse,
315
+ updateSettings: (settings: Partial<ConnectSettings>) => {
316
+ if (_core || pendingInitializations.size > 0) {
317
+ return Promise.reject(ERRORS.TypedError(HardwareErrorCode.IFrameAleradyInitialized));
318
+ }
319
+ _settings = parseConnectSettings({ ..._settings, ...settings });
320
+ return Promise.resolve(true);
321
+ },
322
+ switchTransport: async (env: ConnectSettings['env']) => {
323
+ const owner = _core;
324
+ if (!owner) throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
325
+ await switchCoreTransport({
326
+ env,
327
+ owner,
328
+ loadTransport: () => getTransport(env),
329
+ plugin: _plugin,
330
+ });
331
+ return { success: true, payload: {} };
332
+ },
333
+ });
334
+
242
335
  const HardwareCommonConnectSdk = HardwareSdk({
243
336
  eventEmitter,
244
337
  init,