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

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,25 +28,6 @@ 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
-
50
31
  ## Desktop USB identity discovery
51
32
 
52
33
  `probeUsbDeviceIdentities({ commType: 'webusb' | 'bridge' })` is a named export for
package/dist/index.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
2
- import { UsbDeviceIdentity, LowLevelCoreApi } from '@onekeyfe/hd-core';
2
+ import { UsbDeviceIdentity } 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,7 +9,6 @@ declare const probeUsbDeviceIdentities: ({ commType, }: {
9
9
  declare const messagePromises: {
10
10
  [key: number]: Deferred<any>;
11
11
  };
12
- declare const HardwareSDKLowLevel: LowLevelCoreApi;
13
12
  declare const HardwareCommonConnectSdk: _onekeyfe_hd_core.CoreApi;
14
13
 
15
- export { HardwareSDKLowLevel, HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
14
+ export { HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
package/dist/index.js CHANGED
@@ -606,10 +606,7 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
606
606
  });
607
607
  }); };
608
608
  var _core;
609
- var _plugin;
610
609
  var _settings = HardwareSdk.parseConnectSettings();
611
- var lifecycle = Promise.resolve(undefined);
612
- var pendingInitializations = new Set();
613
610
  var usbIdentityProbeTransports = {};
614
611
  var usbIdentityProbes = {};
615
612
  /** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
@@ -637,26 +634,21 @@ var probeUsbDeviceIdentities = function (_a) {
637
634
  var _messageID = 0;
638
635
  var messagePromises = {};
639
636
  var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
640
- var core, pending, disposing;
641
- return __generator(this, function (_a) {
642
- switch (_a.label) {
637
+ var core;
638
+ var _a;
639
+ return __generator(this, function (_b) {
640
+ switch (_b.label) {
643
641
  case 0:
644
642
  core = _core;
645
- pendingInitializations.forEach(function (controller) { return controller.abort(); });
646
- pendingInitializations.clear();
647
- pending = lifecycle.catch(function () { return undefined; });
648
643
  _core = undefined;
649
- _plugin = undefined;
650
644
  eventEmitter.removeAllListeners();
651
645
  Object.keys(messagePromises).forEach(function (key) {
652
646
  delete messagePromises[Number(key)];
653
647
  });
654
648
  _settings = HardwareSdk.parseConnectSettings();
655
- disposing = Promise.all([pending, core === null || core === void 0 ? void 0 : core.dispose()]);
656
- lifecycle = disposing;
657
- return [4 /*yield*/, disposing];
649
+ return [4 /*yield*/, ((_a = core === null || core === void 0 ? void 0 : core.dispose) === null || _a === void 0 ? void 0 : _a.call(core))];
658
650
  case 1:
659
- _a.sent();
651
+ _b.sent();
660
652
  return [2 /*return*/];
661
653
  }
662
654
  });
@@ -665,9 +657,8 @@ var uiResponse = function (response) {
665
657
  if (!_core) {
666
658
  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
667
659
  }
668
- _core
669
- .handleMessage(__assign(__assign({}, response), { event: HardwareSdk.UI_EVENT }))
670
- .catch(function (error) { return Log.error(HardwareSdk.createErrorMessage(error)); });
660
+ var type = response.type, payload = response.payload;
661
+ _core.handleMessage({ event: HardwareSdk.UI_EVENT, type: type, payload: payload });
671
662
  };
672
663
  var cancel = function (connectId) {
673
664
  if (_core === undefined)
@@ -738,71 +729,35 @@ function postMessage(message, usePromise) {
738
729
  });
739
730
  });
740
731
  }
741
- var init = function (settings, _, plugin) {
732
+ var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, void 0, function () {
733
+ var Transport, error_1;
742
734
  var _a;
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);
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
+ }
802
759
  });
803
- lifecycle = initializing;
804
- return initializing;
805
- };
760
+ }); };
806
761
  var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
807
762
  var blockLog, response, error_2;
808
763
  var _a, _b, _c, _d;
@@ -846,65 +801,6 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
846
801
  }); };
847
802
  var updateSettings = function () { return Promise.resolve(true); };
848
803
  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
- });
908
804
  var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
909
805
  eventEmitter: eventEmitter,
910
806
  init: init,
@@ -916,7 +812,6 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
916
812
  switchTransport: switchTransport,
917
813
  });
918
814
 
919
- exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
920
815
  exports["default"] = HardwareCommonConnectSdk;
921
816
  exports.messagePromises = messagePromises;
922
817
  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.5",
3
+ "version": "1.2.11-alpha.7",
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.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"
24
+ "@onekeyfe/hd-core": "1.2.11-alpha.7",
25
+ "@onekeyfe/hd-shared": "1.2.11-alpha.7",
26
+ "@onekeyfe/hd-transport-emulator": "1.2.11-alpha.7",
27
+ "@onekeyfe/hd-transport-http": "1.2.11-alpha.7",
28
+ "@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.7",
29
+ "@onekeyfe/hd-transport-usb": "1.2.11-alpha.7",
30
+ "@onekeyfe/hd-transport-web-device": "1.2.11-alpha.7"
31
31
  },
32
- "gitHead": "887771a9cc9f75d8230db39b9aa77adee81c3721"
32
+ "gitHead": "45032ae6625b62ff5bf956315dce3a919c48329d"
33
33
  }
package/src/index.ts CHANGED
@@ -1,6 +1,5 @@
1
1
  import EventEmitter from 'events';
2
2
  import HardwareSdk, {
3
- HardwareSDKLowLevel as HardwareLowLevelSdk,
4
3
  CORE_EVENT,
5
4
  DEVICE,
6
5
  DEVICE_EVENT,
@@ -20,7 +19,6 @@ import HardwareSdk, {
20
19
  parseConnectSettings,
21
20
  probeUsbDeviceIdentitiesWithTransport,
22
21
  setLoggerPostMessage,
23
- switchTransport as switchCoreTransport,
24
22
  } from '@onekeyfe/hd-core';
25
23
  import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
26
24
  import HttpTransport from '@onekeyfe/hd-transport-http';
@@ -59,10 +57,7 @@ const getTransport = async (env: ConnectSettings['env']) => {
59
57
  };
60
58
 
61
59
  let _core: Core | undefined;
62
- let _plugin: LowlevelTransportSharedPlugin | undefined;
63
60
  let _settings = parseConnectSettings();
64
- let lifecycle = Promise.resolve<unknown>(undefined);
65
- const pendingInitializations = new Set<AbortController>();
66
61
 
67
62
  const usbIdentityProbeTransports: Partial<Record<UsbDeviceIdentity['commType'], WebUsbTransport>> =
68
63
  {};
@@ -100,28 +95,21 @@ export const messagePromises: { [key: number]: Deferred<any> } = {};
100
95
 
101
96
  const dispose = async () => {
102
97
  const core = _core;
103
- pendingInitializations.forEach(controller => controller.abort());
104
- pendingInitializations.clear();
105
- const pending = lifecycle.catch(() => undefined);
106
98
  _core = undefined;
107
- _plugin = undefined;
108
99
  eventEmitter.removeAllListeners();
109
100
  Object.keys(messagePromises).forEach(key => {
110
101
  delete messagePromises[Number(key)];
111
102
  });
112
103
  _settings = parseConnectSettings();
113
- const disposing = Promise.all([pending, core?.dispose()]);
114
- lifecycle = disposing;
115
- await disposing;
104
+ await core?.dispose?.();
116
105
  };
117
106
 
118
107
  const uiResponse = (response: UiResponseEvent) => {
119
108
  if (!_core) {
120
109
  throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
121
110
  }
122
- _core
123
- .handleMessage({ ...response, event: UI_EVENT } as CoreMessage)
124
- .catch(error => Log.error(createErrorMessage(error)));
111
+ const { type, payload } = response;
112
+ _core.handleMessage({ event: UI_EVENT, type, payload } as CoreMessage);
125
113
  };
126
114
 
127
115
  const cancel = (connectId?: string) => {
@@ -189,53 +177,29 @@ async function postMessage(message: CoreMessage, usePromise = true) {
189
177
  _core.handleMessage(message);
190
178
  }
191
179
 
192
- const init = (
180
+ const init = async (
193
181
  settings: Partial<ConnectSettings>,
194
182
  _?: LowLevelCoreApi,
195
183
  plugin?: LowlevelTransportSharedPlugin
196
184
  ) => {
197
185
  _settings = { ..._settings, ...settings, env: settings.env ?? 'node' };
198
- const initSettings = _settings;
199
- const controller = new AbortController();
200
- const { signal } = controller;
201
- pendingInitializations.add(controller);
202
186
 
203
- const initialize = async () => {
204
- if (signal.aborted) return false;
205
- enableLog(!!settings.debug);
206
- Log.debug('init');
187
+ enableLog(!!settings.debug);
207
188
 
208
- try {
209
- const Transport = await getTransport(initSettings.env);
210
- if (signal.aborted) return false;
189
+ Log.debug('init');
211
190
 
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
- };
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);
233
196
 
234
- const initializing = lifecycle.then(initialize, initialize).finally(() => {
235
- pendingInitializations.delete(controller);
236
- });
237
- lifecycle = initializing;
238
- return initializing;
197
+ return true;
198
+ } catch (error) {
199
+ Log.error(createErrorMessage(error));
200
+
201
+ return false;
202
+ }
239
203
  };
240
204
 
241
205
  const call = async (params: any) => {
@@ -275,58 +239,6 @@ const call = async (params: any) => {
275
239
  const updateSettings = () => Promise.resolve(true);
276
240
  const switchTransport = () => Promise.resolve({ success: true });
277
241
 
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
-
330
242
  const HardwareCommonConnectSdk = HardwareSdk({
331
243
  eventEmitter,
332
244
  init,
@@ -1,239 +0,0 @@
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
- });