@onekeyfe/hd-common-connect-sdk 1.2.11-alpha.3 → 1.2.11-alpha.5

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,25 @@ 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 host still obtains WebUSB permission through a user gesture and handles device
46
+ confirmation, PIN and passphrase events. An extension service worker should proxy
47
+ to its offscreen host. Use one active SDK host per runtime and dispose it before
48
+ replacing it. The package's default SDK export keeps its existing behavior.
49
+
31
50
  ## Desktop USB identity discovery
32
51
 
33
52
  `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
@@ -606,7 +606,10 @@ 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 lifecycle = Promise.resolve(undefined);
612
+ var pendingInitializations = new Set();
610
613
  var usbIdentityProbeTransports = {};
611
614
  var usbIdentityProbes = {};
612
615
  /** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
@@ -634,21 +637,26 @@ var probeUsbDeviceIdentities = function (_a) {
634
637
  var _messageID = 0;
635
638
  var messagePromises = {};
636
639
  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) {
640
+ var core, pending, disposing;
641
+ return __generator(this, function (_a) {
642
+ switch (_a.label) {
641
643
  case 0:
642
644
  core = _core;
645
+ pendingInitializations.forEach(function (controller) { return controller.abort(); });
646
+ pendingInitializations.clear();
647
+ pending = lifecycle.catch(function () { return undefined; });
643
648
  _core = undefined;
649
+ _plugin = undefined;
644
650
  eventEmitter.removeAllListeners();
645
651
  Object.keys(messagePromises).forEach(function (key) {
646
652
  delete messagePromises[Number(key)];
647
653
  });
648
654
  _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))];
655
+ disposing = Promise.all([pending, core === null || core === void 0 ? void 0 : core.dispose()]);
656
+ lifecycle = disposing;
657
+ return [4 /*yield*/, disposing];
650
658
  case 1:
651
- _b.sent();
659
+ _a.sent();
652
660
  return [2 /*return*/];
653
661
  }
654
662
  });
@@ -657,8 +665,9 @@ var uiResponse = function (response) {
657
665
  if (!_core) {
658
666
  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
659
667
  }
660
- var type = response.type, payload = response.payload;
661
- _core.handleMessage({ event: HardwareSdk.UI_EVENT, type: type, payload: payload });
668
+ _core
669
+ .handleMessage(__assign(__assign({}, response), { event: HardwareSdk.UI_EVENT }))
670
+ .catch(function (error) { return Log.error(HardwareSdk.createErrorMessage(error)); });
662
671
  };
663
672
  var cancel = function (connectId) {
664
673
  if (_core === undefined)
@@ -729,35 +738,71 @@ function postMessage(message, usePromise) {
729
738
  });
730
739
  });
731
740
  }
732
- var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, void 0, function () {
733
- var Transport, error_1;
741
+ var init = function (settings, _, plugin) {
734
742
  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
- }
743
+ _settings = __assign(__assign(__assign({}, _settings), settings), { env: (_a = settings.env) !== null && _a !== void 0 ? _a : 'node' });
744
+ var initSettings = _settings;
745
+ var controller = new AbortController();
746
+ var signal = controller.signal;
747
+ pendingInitializations.add(controller);
748
+ var initialize = function () { return __awaiter(void 0, void 0, void 0, function () {
749
+ var Transport, previous, core, error_1;
750
+ return __generator(this, function (_a) {
751
+ switch (_a.label) {
752
+ case 0:
753
+ if (signal.aborted)
754
+ return [2 /*return*/, false];
755
+ HardwareSdk.enableLog(!!settings.debug);
756
+ Log.debug('init');
757
+ _a.label = 1;
758
+ case 1:
759
+ _a.trys.push([1, 8, , 9]);
760
+ return [4 /*yield*/, getTransport(initSettings.env)];
761
+ case 2:
762
+ Transport = _a.sent();
763
+ if (signal.aborted)
764
+ return [2 /*return*/, false];
765
+ previous = _core;
766
+ _core = undefined;
767
+ _plugin = undefined;
768
+ if (!previous) return [3 /*break*/, 4];
769
+ return [4 /*yield*/, previous.dispose()];
770
+ case 3:
771
+ _a.sent();
772
+ _a.label = 4;
773
+ case 4:
774
+ if (signal.aborted)
775
+ return [2 /*return*/, false];
776
+ return [4 /*yield*/, HardwareSdk.initCore(initSettings, Transport, plugin, signal)];
777
+ case 5:
778
+ core = _a.sent();
779
+ if (!core)
780
+ return [2 /*return*/, false];
781
+ if (!signal.aborted) return [3 /*break*/, 7];
782
+ return [4 /*yield*/, core.dispose()];
783
+ case 6:
784
+ _a.sent();
785
+ return [2 /*return*/, false];
786
+ case 7:
787
+ _core = core;
788
+ _plugin = plugin;
789
+ core.on(HardwareSdk.CORE_EVENT, handleMessage);
790
+ HardwareSdk.setLoggerPostMessage(handleMessage);
791
+ return [2 /*return*/, true];
792
+ case 8:
793
+ error_1 = _a.sent();
794
+ Log.error(HardwareSdk.createErrorMessage(error_1));
795
+ return [2 /*return*/, false];
796
+ case 9: return [2 /*return*/];
797
+ }
798
+ });
799
+ }); };
800
+ var initializing = lifecycle.then(initialize, initialize).finally(function () {
801
+ pendingInitializations.delete(controller);
759
802
  });
760
- }); };
803
+ lifecycle = initializing;
804
+ return initializing;
805
+ };
761
806
  var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
762
807
  var blockLog, response, error_2;
763
808
  var _a, _b, _c, _d;
@@ -801,6 +846,65 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
801
846
  }); };
802
847
  var updateSettings = function () { return Promise.resolve(true); };
803
848
  var switchTransport = function () { return Promise.resolve({ success: true }); };
849
+ var addHardwareGlobalEventListener = function (listener) {
850
+ [
851
+ HardwareSdk.UI_EVENT,
852
+ HardwareSdk.LOG_EVENT,
853
+ HardwareSdk.FIRMWARE_EVENT,
854
+ HardwareSdk.DEVICE.CONNECT,
855
+ HardwareSdk.DEVICE.DISCONNECT,
856
+ HardwareSdk.DEVICE.FEATURES,
857
+ HardwareSdk.DEVICE.STATE,
858
+ HardwareSdk.DEVICE.SUPPORT_FEATURES,
859
+ ].forEach(function (eventName) {
860
+ eventEmitter.on(eventName, function (message) {
861
+ // Match the Web SDK envelope for device events emitted as payloads.
862
+ var envelope = message;
863
+ var emitMessage = message;
864
+ if (!envelope.event && !envelope.type) {
865
+ emitMessage = __assign({}, message);
866
+ Object.assign(emitMessage, { event: eventName, type: eventName });
867
+ }
868
+ listener(emitMessage);
869
+ });
870
+ });
871
+ };
872
+ var HardwareSDKLowLevel = HardwareSdk.HardwareSDKLowLevel({
873
+ eventEmitter: eventEmitter,
874
+ init: function (settings, sdk, plugin) { return init(__assign(__assign({}, _settings), settings), sdk, plugin); },
875
+ call: call,
876
+ cancel: cancel,
877
+ dispose: dispose,
878
+ addHardwareGlobalEventListener: addHardwareGlobalEventListener,
879
+ uiResponse: uiResponse,
880
+ updateSettings: function (settings) {
881
+ if (_core || pendingInitializations.size > 0) {
882
+ return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.IFrameAleradyInitialized));
883
+ }
884
+ _settings = HardwareSdk.parseConnectSettings(__assign(__assign({}, _settings), settings));
885
+ return Promise.resolve(true);
886
+ },
887
+ switchTransport: function (env) { return __awaiter(void 0, void 0, void 0, function () {
888
+ var owner;
889
+ return __generator(this, function (_a) {
890
+ switch (_a.label) {
891
+ case 0:
892
+ owner = _core;
893
+ if (!owner)
894
+ throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
895
+ return [4 /*yield*/, HardwareSdk.switchTransport({
896
+ env: env,
897
+ owner: owner,
898
+ loadTransport: function () { return getTransport(env); },
899
+ plugin: _plugin,
900
+ })];
901
+ case 1:
902
+ _a.sent();
903
+ return [2 /*return*/, { success: true, payload: {} }];
904
+ }
905
+ });
906
+ }); },
907
+ });
804
908
  var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
805
909
  eventEmitter: eventEmitter,
806
910
  init: init,
@@ -812,6 +916,7 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
812
916
  switchTransport: switchTransport,
813
917
  });
814
918
 
919
+ exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
815
920
  exports["default"] = HardwareCommonConnectSdk;
816
921
  exports.messagePromises = messagePromises;
817
922
  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.11-alpha.3",
3
+ "version": "1.2.11-alpha.5",
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.11-alpha.3",
25
- "@onekeyfe/hd-shared": "1.2.11-alpha.3",
26
- "@onekeyfe/hd-transport-emulator": "1.2.11-alpha.3",
27
- "@onekeyfe/hd-transport-http": "1.2.11-alpha.3",
28
- "@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.3",
29
- "@onekeyfe/hd-transport-usb": "1.2.11-alpha.3",
30
- "@onekeyfe/hd-transport-web-device": "1.2.11-alpha.3"
24
+ "@onekeyfe/hd-core": "1.2.11-alpha.5",
25
+ "@onekeyfe/hd-shared": "1.2.11-alpha.5",
26
+ "@onekeyfe/hd-transport-emulator": "1.2.11-alpha.5",
27
+ "@onekeyfe/hd-transport-http": "1.2.11-alpha.5",
28
+ "@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.5",
29
+ "@onekeyfe/hd-transport-usb": "1.2.11-alpha.5",
30
+ "@onekeyfe/hd-transport-web-device": "1.2.11-alpha.5"
31
31
  },
32
- "gitHead": "350063c5fbcbd2461c37c2d8419ce9d0e0e5fa4d"
32
+ "gitHead": "887771a9cc9f75d8230db39b9aa77adee81c3721"
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,
@@ -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';
@@ -57,7 +59,10 @@ const getTransport = async (env: ConnectSettings['env']) => {
57
59
  };
58
60
 
59
61
  let _core: Core | undefined;
62
+ let _plugin: LowlevelTransportSharedPlugin | undefined;
60
63
  let _settings = parseConnectSettings();
64
+ let lifecycle = Promise.resolve<unknown>(undefined);
65
+ const pendingInitializations = new Set<AbortController>();
61
66
 
62
67
  const usbIdentityProbeTransports: Partial<Record<UsbDeviceIdentity['commType'], WebUsbTransport>> =
63
68
  {};
@@ -95,21 +100,28 @@ export const messagePromises: { [key: number]: Deferred<any> } = {};
95
100
 
96
101
  const dispose = async () => {
97
102
  const core = _core;
103
+ pendingInitializations.forEach(controller => controller.abort());
104
+ pendingInitializations.clear();
105
+ const pending = lifecycle.catch(() => undefined);
98
106
  _core = undefined;
107
+ _plugin = undefined;
99
108
  eventEmitter.removeAllListeners();
100
109
  Object.keys(messagePromises).forEach(key => {
101
110
  delete messagePromises[Number(key)];
102
111
  });
103
112
  _settings = parseConnectSettings();
104
- await core?.dispose?.();
113
+ const disposing = Promise.all([pending, core?.dispose()]);
114
+ lifecycle = disposing;
115
+ await disposing;
105
116
  };
106
117
 
107
118
  const uiResponse = (response: UiResponseEvent) => {
108
119
  if (!_core) {
109
120
  throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
110
121
  }
111
- const { type, payload } = response;
112
- _core.handleMessage({ event: UI_EVENT, type, payload } as CoreMessage);
122
+ _core
123
+ .handleMessage({ ...response, event: UI_EVENT } as CoreMessage)
124
+ .catch(error => Log.error(createErrorMessage(error)));
113
125
  };
114
126
 
115
127
  const cancel = (connectId?: string) => {
@@ -177,29 +189,53 @@ async function postMessage(message: CoreMessage, usePromise = true) {
177
189
  _core.handleMessage(message);
178
190
  }
179
191
 
180
- const init = async (
192
+ const init = (
181
193
  settings: Partial<ConnectSettings>,
182
194
  _?: LowLevelCoreApi,
183
195
  plugin?: LowlevelTransportSharedPlugin
184
196
  ) => {
185
197
  _settings = { ..._settings, ...settings, env: settings.env ?? 'node' };
198
+ const initSettings = _settings;
199
+ const controller = new AbortController();
200
+ const { signal } = controller;
201
+ pendingInitializations.add(controller);
186
202
 
187
- enableLog(!!settings.debug);
203
+ const initialize = async () => {
204
+ if (signal.aborted) return false;
205
+ enableLog(!!settings.debug);
206
+ Log.debug('init');
188
207
 
189
- Log.debug('init');
190
-
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);
208
+ try {
209
+ const Transport = await getTransport(initSettings.env);
210
+ if (signal.aborted) return false;
196
211
 
197
- return true;
198
- } catch (error) {
199
- Log.error(createErrorMessage(error));
212
+ const previous = _core;
213
+ _core = undefined;
214
+ _plugin = undefined;
215
+ if (previous) await previous.dispose();
216
+ if (signal.aborted) return false;
217
+ const core = await initCore(initSettings, Transport, plugin, signal);
218
+ if (!core) return false;
219
+ if (signal.aborted) {
220
+ await core.dispose();
221
+ return false;
222
+ }
223
+ _core = core;
224
+ _plugin = plugin;
225
+ core.on(CORE_EVENT, handleMessage);
226
+ setLoggerPostMessage(handleMessage);
227
+ return true;
228
+ } catch (error) {
229
+ Log.error(createErrorMessage(error));
230
+ return false;
231
+ }
232
+ };
200
233
 
201
- return false;
202
- }
234
+ const initializing = lifecycle.then(initialize, initialize).finally(() => {
235
+ pendingInitializations.delete(controller);
236
+ });
237
+ lifecycle = initializing;
238
+ return initializing;
203
239
  };
204
240
 
205
241
  const call = async (params: any) => {
@@ -239,6 +275,58 @@ const call = async (params: any) => {
239
275
  const updateSettings = () => Promise.resolve(true);
240
276
  const switchTransport = () => Promise.resolve({ success: true });
241
277
 
278
+ const addHardwareGlobalEventListener = (listener: (message: CoreMessage) => void) => {
279
+ [
280
+ UI_EVENT,
281
+ LOG_EVENT,
282
+ FIRMWARE_EVENT,
283
+ DEVICE.CONNECT,
284
+ DEVICE.DISCONNECT,
285
+ DEVICE.FEATURES,
286
+ DEVICE.STATE,
287
+ DEVICE.SUPPORT_FEATURES,
288
+ ].forEach(eventName => {
289
+ eventEmitter.on(eventName, (message: CoreMessage) => {
290
+ // Match the Web SDK envelope for device events emitted as payloads.
291
+ const envelope: { event?: string; type?: string } = message;
292
+ let emitMessage = message;
293
+ if (!envelope.event && !envelope.type) {
294
+ emitMessage = { ...message };
295
+ Object.assign(emitMessage, { event: eventName, type: eventName });
296
+ }
297
+ listener(emitMessage);
298
+ });
299
+ });
300
+ };
301
+
302
+ export const HardwareSDKLowLevel = HardwareLowLevelSdk({
303
+ eventEmitter,
304
+ init: (settings, sdk, plugin) => init({ ..._settings, ...settings }, sdk, plugin),
305
+ call,
306
+ cancel,
307
+ dispose,
308
+ addHardwareGlobalEventListener,
309
+ uiResponse,
310
+ updateSettings: (settings: Partial<ConnectSettings>) => {
311
+ if (_core || pendingInitializations.size > 0) {
312
+ return Promise.reject(ERRORS.TypedError(HardwareErrorCode.IFrameAleradyInitialized));
313
+ }
314
+ _settings = parseConnectSettings({ ..._settings, ...settings });
315
+ return Promise.resolve(true);
316
+ },
317
+ switchTransport: async (env: ConnectSettings['env']) => {
318
+ const owner = _core;
319
+ if (!owner) throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
320
+ await switchCoreTransport({
321
+ env,
322
+ owner,
323
+ loadTransport: () => getTransport(env),
324
+ plugin: _plugin,
325
+ });
326
+ return { success: true, payload: {} };
327
+ },
328
+ });
329
+
242
330
  const HardwareCommonConnectSdk = HardwareSdk({
243
331
  eventEmitter,
244
332
  init,