@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 +19 -0
- package/__tests__/direct-lowlevel.test.js +239 -0
- package/dist/index.d.ts +3 -2
- package/dist/index.js +140 -35
- package/package.json +9 -9
- package/src/index.ts +105 -17
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
|
-
|
|
639
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
661
|
-
|
|
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) {
|
|
733
|
-
var Transport, error_1;
|
|
741
|
+
var init = function (settings, _, plugin) {
|
|
734
742
|
var _a;
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
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
|
+
"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.
|
|
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.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": "
|
|
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
|
-
|
|
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
|
-
|
|
112
|
-
|
|
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 =
|
|
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
|
-
|
|
203
|
+
const initialize = async () => {
|
|
204
|
+
if (signal.aborted) return false;
|
|
205
|
+
enableLog(!!settings.debug);
|
|
206
|
+
Log.debug('init');
|
|
188
207
|
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
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
|
-
|
|
198
|
-
|
|
199
|
-
|
|
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
|
-
|
|
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,
|