@onekeyfe/hd-common-connect-sdk 1.2.11-alpha.5 → 1.2.11-alpha.8
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 +0 -19
- package/dist/index.d.ts +2 -3
- package/dist/index.js +35 -140
- package/package.json +9 -9
- package/src/index.ts +17 -105
- package/__tests__/direct-lowlevel.test.js +0 -239
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
|
|
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 {
|
|
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
|
|
641
|
-
|
|
642
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
669
|
-
|
|
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
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
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
|
-
|
|
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.
|
|
3
|
+
"version": "1.2.11-alpha.8",
|
|
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.
|
|
25
|
-
"@onekeyfe/hd-shared": "1.2.11-alpha.
|
|
26
|
-
"@onekeyfe/hd-transport-emulator": "1.2.11-alpha.
|
|
27
|
-
"@onekeyfe/hd-transport-http": "1.2.11-alpha.
|
|
28
|
-
"@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.
|
|
29
|
-
"@onekeyfe/hd-transport-usb": "1.2.11-alpha.
|
|
30
|
-
"@onekeyfe/hd-transport-web-device": "1.2.11-alpha.
|
|
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"
|
|
31
31
|
},
|
|
32
|
-
"gitHead": "
|
|
32
|
+
"gitHead": "f2f0e4af13efbb09f4b421171142f9144124a1c2"
|
|
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
|
-
|
|
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
|
-
|
|
123
|
-
|
|
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
|
-
|
|
204
|
-
if (signal.aborted) return false;
|
|
205
|
-
enableLog(!!settings.debug);
|
|
206
|
-
Log.debug('init');
|
|
187
|
+
enableLog(!!settings.debug);
|
|
207
188
|
|
|
208
|
-
|
|
209
|
-
const Transport = await getTransport(initSettings.env);
|
|
210
|
-
if (signal.aborted) return false;
|
|
189
|
+
Log.debug('init');
|
|
211
190
|
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
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
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
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
|
-
});
|