@onekeyfe/hd-common-connect-sdk 1.2.11-alpha.4 → 1.2.11-alpha.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +24 -1
- package/__tests__/direct-lowlevel.test.js +239 -0
- package/dist/index.d.ts +3 -2
- package/dist/index.js +144 -35
- package/package.json +16 -10
- package/scripts/check-bundle.mjs +35 -0
- package/src/index.ts +112 -19
package/README.md
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
# `@onekeyfe/hd-common-connect-sdk`
|
|
2
2
|
|
|
3
|
-
`@onekeyfe/hd-common-connect-sdk` is a
|
|
3
|
+
`@onekeyfe/hd-common-connect-sdk` is a unified in-process Hardware SDK entry point that runs Core and the selected transport directly in Node.js, Electron, browser/extension, and native bridge (`lowlevel`) runtimes.
|
|
4
4
|
|
|
5
5
|
## Installation
|
|
6
6
|
|
|
@@ -28,6 +28,29 @@ function init() {
|
|
|
28
28
|
}
|
|
29
29
|
```
|
|
30
30
|
|
|
31
|
+
## Local LowLevel host
|
|
32
|
+
|
|
33
|
+
The named `HardwareSDKLowLevel` export runs Core and the selected transport in the
|
|
34
|
+
same JavaScript runtime. A trusted local host, including an extension offscreen
|
|
35
|
+
document, can use it without a hardware SDK iframe:
|
|
36
|
+
|
|
37
|
+
```typescript
|
|
38
|
+
import { HardwareSDKLowLevel } from '@onekeyfe/hd-common-connect-sdk';
|
|
39
|
+
|
|
40
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
41
|
+
// Forward SDK calls and correlated UI responses through the host's existing bridge.
|
|
42
|
+
await HardwareSDKLowLevel.dispose();
|
|
43
|
+
```
|
|
44
|
+
|
|
45
|
+
The package's `browser` mapping excludes the native USB dependency from browser
|
|
46
|
+
bundles. The browser host still needs a `Buffer` polyfill for Core and its
|
|
47
|
+
dependencies. Use `env: 'node-usb'` from a Node.js build.
|
|
48
|
+
|
|
49
|
+
The host still obtains WebUSB permission through a user gesture and handles device
|
|
50
|
+
confirmation, PIN and passphrase events. An extension service worker should proxy
|
|
51
|
+
to its offscreen host. Use one active SDK host per runtime and dispose it before
|
|
52
|
+
replacing it. The package's default SDK export keeps its existing behavior.
|
|
53
|
+
|
|
31
54
|
## Desktop USB identity discovery
|
|
32
55
|
|
|
33
56
|
`probeUsbDeviceIdentities({ commType: 'webusb' | 'bridge' })` is a named export for
|
|
@@ -0,0 +1,239 @@
|
|
|
1
|
+
import EventEmitter from 'events';
|
|
2
|
+
import {
|
|
3
|
+
CORE_EVENT,
|
|
4
|
+
DEVICE,
|
|
5
|
+
DEVICE_EVENT,
|
|
6
|
+
UI_EVENT,
|
|
7
|
+
UI_REQUEST,
|
|
8
|
+
IFRAME,
|
|
9
|
+
UI_RESPONSE,
|
|
10
|
+
initCore,
|
|
11
|
+
switchTransport,
|
|
12
|
+
} from '@onekeyfe/hd-core';
|
|
13
|
+
import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
|
|
14
|
+
|
|
15
|
+
import { HardwareSDKLowLevel } from '../src';
|
|
16
|
+
|
|
17
|
+
jest.mock('../../core/src/data/config', () => ({
|
|
18
|
+
getSDKVersion: jest.fn(() => '1.0.0-test'),
|
|
19
|
+
DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
|
|
20
|
+
}));
|
|
21
|
+
jest.mock('@onekeyfe/hd-core', () => ({
|
|
22
|
+
__esModule: true,
|
|
23
|
+
...jest.requireActual('@onekeyfe/hd-core'),
|
|
24
|
+
initCore: jest.fn(),
|
|
25
|
+
switchTransport: jest.fn(),
|
|
26
|
+
}));
|
|
27
|
+
jest.mock('@onekeyfe/hd-transport-http', () => ({}));
|
|
28
|
+
jest.mock('@onekeyfe/hd-transport-web-device', () => ({ WebUsbTransport: {} }));
|
|
29
|
+
jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
|
|
30
|
+
jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
|
|
31
|
+
|
|
32
|
+
const core = Object.assign(new EventEmitter(), {
|
|
33
|
+
handleMessage: jest.fn(),
|
|
34
|
+
dispose: jest.fn(() => {
|
|
35
|
+
core.removeAllListeners();
|
|
36
|
+
return Promise.resolve();
|
|
37
|
+
}),
|
|
38
|
+
});
|
|
39
|
+
|
|
40
|
+
beforeEach(() => {
|
|
41
|
+
jest.clearAllMocks();
|
|
42
|
+
initCore.mockResolvedValue(core);
|
|
43
|
+
});
|
|
44
|
+
afterEach(async () => HardwareSDKLowLevel.dispose());
|
|
45
|
+
|
|
46
|
+
test('initializes, calls and switches the local Core without a DOM or iframe', async () => {
|
|
47
|
+
expect(typeof document).toBe('undefined');
|
|
48
|
+
expect(await HardwareSDKLowLevel.init({ env: 'webusb' })).toBe(true);
|
|
49
|
+
expect(initCore).toHaveBeenCalledWith(
|
|
50
|
+
expect.objectContaining({ env: 'webusb' }),
|
|
51
|
+
expect.anything(),
|
|
52
|
+
undefined,
|
|
53
|
+
expect.any(AbortSignal)
|
|
54
|
+
);
|
|
55
|
+
const response = { success: true, payload: { test: true } };
|
|
56
|
+
core.handleMessage.mockResolvedValue(response);
|
|
57
|
+
expect(await HardwareSDKLowLevel.call({ method: 'getFeatures' })).toBe(response);
|
|
58
|
+
expect(core.handleMessage).toHaveBeenCalledWith(
|
|
59
|
+
expect.objectContaining({
|
|
60
|
+
event: IFRAME.CALL,
|
|
61
|
+
type: IFRAME.CALL,
|
|
62
|
+
payload: expect.objectContaining({ method: 'getFeatures' }),
|
|
63
|
+
})
|
|
64
|
+
);
|
|
65
|
+
expect(await HardwareSDKLowLevel.switchTransport('webusb')).toStrictEqual({
|
|
66
|
+
success: true,
|
|
67
|
+
payload: {},
|
|
68
|
+
});
|
|
69
|
+
expect(switchTransport).toHaveBeenCalledWith({
|
|
70
|
+
env: 'webusb',
|
|
71
|
+
owner: core,
|
|
72
|
+
loadTransport: expect.any(Function),
|
|
73
|
+
plugin: undefined,
|
|
74
|
+
});
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
test('keeps the Web LowLevel event envelope and cleans listeners on dispose', async () => {
|
|
78
|
+
const listener = jest.fn();
|
|
79
|
+
HardwareSDKLowLevel.addHardwareGlobalEventListener(listener);
|
|
80
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
81
|
+
const payload = { device: { label: 'Synthetic device' } };
|
|
82
|
+
core.emit(CORE_EVENT, { event: DEVICE_EVENT, type: DEVICE.CONNECT, payload });
|
|
83
|
+
expect(listener).toHaveBeenLastCalledWith({
|
|
84
|
+
...payload,
|
|
85
|
+
event: DEVICE.CONNECT,
|
|
86
|
+
type: DEVICE.CONNECT,
|
|
87
|
+
});
|
|
88
|
+
const message = { event: UI_EVENT, type: UI_REQUEST.REQUEST_BUTTON, payload: {} };
|
|
89
|
+
core.emit(CORE_EVENT, message);
|
|
90
|
+
expect(listener).toHaveBeenLastCalledWith(message);
|
|
91
|
+
await HardwareSDKLowLevel.dispose();
|
|
92
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
93
|
+
listener.mockClear();
|
|
94
|
+
core.emit(CORE_EVENT, message);
|
|
95
|
+
expect(listener).not.toHaveBeenCalled();
|
|
96
|
+
expect(core.listenerCount(CORE_EVENT)).toBe(1);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
test('uses settings staged before initialization', async () => {
|
|
100
|
+
await HardwareSDKLowLevel.updateSettings({ env: 'webusb' });
|
|
101
|
+
await HardwareSDKLowLevel.init({ debug: false });
|
|
102
|
+
expect(initCore).toHaveBeenCalledWith(
|
|
103
|
+
expect.objectContaining({ env: 'webusb' }),
|
|
104
|
+
expect.anything(),
|
|
105
|
+
undefined,
|
|
106
|
+
expect.any(AbortSignal)
|
|
107
|
+
);
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
test('reports settings errors through the Promise contract', async () => {
|
|
111
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
112
|
+
const result = HardwareSDKLowLevel.updateSettings({});
|
|
113
|
+
await expect(result).rejects.toMatchObject({
|
|
114
|
+
errorCode: HardwareErrorCode.IFrameAleradyInitialized,
|
|
115
|
+
});
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
test('rejects settings updates as soon as initialization is queued', async () => {
|
|
119
|
+
const initializing = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: true });
|
|
120
|
+
|
|
121
|
+
await expect(
|
|
122
|
+
HardwareSDKLowLevel.updateSettings({ firmwareManifestMode: 'external-only' })
|
|
123
|
+
).rejects.toMatchObject({ errorCode: HardwareErrorCode.IFrameAleradyInitialized });
|
|
124
|
+
|
|
125
|
+
await expect(initializing).resolves.toBe(true);
|
|
126
|
+
});
|
|
127
|
+
|
|
128
|
+
test.each([
|
|
129
|
+
UI_REQUEST.FIRMWARE_PROGRESS,
|
|
130
|
+
UI_REQUEST.FIRMWARE_TIP,
|
|
131
|
+
UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
|
|
132
|
+
])('forwards %s once with the original UI envelope', async type => {
|
|
133
|
+
const listener = jest.fn();
|
|
134
|
+
HardwareSDKLowLevel.addHardwareGlobalEventListener(listener);
|
|
135
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
136
|
+
const message = { event: UI_EVENT, type, payload: { progress: 1 } };
|
|
137
|
+
core.emit(CORE_EVENT, message);
|
|
138
|
+
expect(listener).toHaveBeenCalledTimes(1);
|
|
139
|
+
expect(listener).toHaveBeenCalledWith(message);
|
|
140
|
+
});
|
|
141
|
+
|
|
142
|
+
test('waits for an in-flight initialization to release its Core on dispose', async () => {
|
|
143
|
+
const entered = createDeferred();
|
|
144
|
+
const initializingCore = createDeferred();
|
|
145
|
+
const cleanupStarted = createDeferred();
|
|
146
|
+
const cleanupFinished = createDeferred();
|
|
147
|
+
initCore.mockImplementationOnce(() => {
|
|
148
|
+
entered.resolve();
|
|
149
|
+
return initializingCore.promise;
|
|
150
|
+
});
|
|
151
|
+
core.dispose.mockImplementationOnce(() => {
|
|
152
|
+
cleanupStarted.resolve();
|
|
153
|
+
return cleanupFinished.promise;
|
|
154
|
+
});
|
|
155
|
+
const initializing = HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
156
|
+
await entered.promise;
|
|
157
|
+
const disposing = HardwareSDKLowLevel.dispose();
|
|
158
|
+
const settled = jest.fn();
|
|
159
|
+
const completion = disposing.then(settled);
|
|
160
|
+
initializingCore.resolve(core);
|
|
161
|
+
try {
|
|
162
|
+
await Promise.race([cleanupStarted.promise, disposing]);
|
|
163
|
+
expect(settled).not.toHaveBeenCalled();
|
|
164
|
+
} finally {
|
|
165
|
+
cleanupFinished.resolve();
|
|
166
|
+
}
|
|
167
|
+
await completion;
|
|
168
|
+
expect(await initializing).toBe(false);
|
|
169
|
+
expect(core.dispose).toHaveBeenCalledTimes(1);
|
|
170
|
+
expect(core.listenerCount(CORE_EVENT)).toBe(0);
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
test('cancels initialization on disposal and lets the next initialization proceed', async () => {
|
|
174
|
+
const started = createDeferred();
|
|
175
|
+
initCore.mockImplementationOnce((_settings, _transport, _plugin, signal) => {
|
|
176
|
+
started.resolve();
|
|
177
|
+
return new Promise(resolve => {
|
|
178
|
+
signal.addEventListener('abort', () => resolve(undefined), { once: true });
|
|
179
|
+
});
|
|
180
|
+
});
|
|
181
|
+
|
|
182
|
+
const abandoned = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: true });
|
|
183
|
+
await started.promise;
|
|
184
|
+
const disposing = HardwareSDKLowLevel.dispose();
|
|
185
|
+
const restarted = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: false });
|
|
186
|
+
|
|
187
|
+
await expect(disposing).resolves.toBeUndefined();
|
|
188
|
+
await expect(abandoned).resolves.toBe(false);
|
|
189
|
+
await expect(restarted).resolves.toBe(true);
|
|
190
|
+
expect(core.listenerCount(CORE_EVENT)).toBe(1);
|
|
191
|
+
});
|
|
192
|
+
|
|
193
|
+
test('binds the switch to its Core before waiting for the transport', async () => {
|
|
194
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
195
|
+
const switching = HardwareSDKLowLevel.switchTransport('webusb');
|
|
196
|
+
expect(switchTransport).toHaveBeenCalledWith({
|
|
197
|
+
env: 'webusb',
|
|
198
|
+
owner: core,
|
|
199
|
+
loadTransport: expect.any(Function),
|
|
200
|
+
plugin: undefined,
|
|
201
|
+
});
|
|
202
|
+
await switching;
|
|
203
|
+
});
|
|
204
|
+
|
|
205
|
+
test('preserves PIN and passphrase response correlation through the real Common adapter', async () => {
|
|
206
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
207
|
+
core.handleMessage.mockResolvedValue(undefined);
|
|
208
|
+
for (const type of [UI_RESPONSE.RECEIVE_PIN, UI_RESPONSE.RECEIVE_PASSPHRASE]) {
|
|
209
|
+
const response = {
|
|
210
|
+
type,
|
|
211
|
+
payload: type === UI_RESPONSE.RECEIVE_PIN ? '' : { value: '', passphraseOnDevice: true },
|
|
212
|
+
interactionId: 'synthetic-interaction',
|
|
213
|
+
deviceId: 'synthetic-device',
|
|
214
|
+
};
|
|
215
|
+
HardwareSDKLowLevel.uiResponse(response);
|
|
216
|
+
expect(core.handleMessage).toHaveBeenLastCalledWith({ ...response, event: UI_EVENT });
|
|
217
|
+
}
|
|
218
|
+
});
|
|
219
|
+
|
|
220
|
+
test('transport switching waits for completion and propagates rejection', async () => {
|
|
221
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
222
|
+
let finish;
|
|
223
|
+
switchTransport.mockReturnValueOnce(
|
|
224
|
+
new Promise(resolve => {
|
|
225
|
+
finish = resolve;
|
|
226
|
+
})
|
|
227
|
+
);
|
|
228
|
+
const settled = jest.fn();
|
|
229
|
+
const switching = HardwareSDKLowLevel.switchTransport('webusb').then(settled);
|
|
230
|
+
await Promise.resolve();
|
|
231
|
+
await Promise.resolve();
|
|
232
|
+
expect(settled).not.toHaveBeenCalled();
|
|
233
|
+
finish();
|
|
234
|
+
await switching;
|
|
235
|
+
expect(settled).toHaveBeenCalledWith({ success: true, payload: {} });
|
|
236
|
+
const failure = new Error('synthetic switch failure');
|
|
237
|
+
switchTransport.mockRejectedValueOnce(failure);
|
|
238
|
+
await expect(HardwareSDKLowLevel.switchTransport('webusb')).rejects.toBe(failure);
|
|
239
|
+
});
|
package/dist/index.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
|
|
2
|
-
import { UsbDeviceIdentity } from '@onekeyfe/hd-core';
|
|
2
|
+
import { UsbDeviceIdentity, LowLevelCoreApi } from '@onekeyfe/hd-core';
|
|
3
3
|
import { Deferred } from '@onekeyfe/hd-shared';
|
|
4
4
|
|
|
5
5
|
/** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
|
|
@@ -9,6 +9,7 @@ declare const probeUsbDeviceIdentities: ({ commType, }: {
|
|
|
9
9
|
declare const messagePromises: {
|
|
10
10
|
[key: number]: Deferred<any>;
|
|
11
11
|
};
|
|
12
|
+
declare const HardwareSDKLowLevel: LowLevelCoreApi;
|
|
12
13
|
declare const HardwareCommonConnectSdk: _onekeyfe_hd_core.CoreApi;
|
|
13
14
|
|
|
14
|
-
export { HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
|
|
15
|
+
export { HardwareSDKLowLevel, HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
|
package/dist/index.js
CHANGED
|
@@ -597,6 +597,10 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
|
|
|
597
597
|
return [4 /*yield*/, Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@onekeyfe/hd-transport-usb')); })];
|
|
598
598
|
case 1:
|
|
599
599
|
NodeUsbTransport = (_a.sent()).default;
|
|
600
|
+
// Browser bundlers replace this Node-only package with an empty module.
|
|
601
|
+
if (typeof NodeUsbTransport !== 'function') {
|
|
602
|
+
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Node USB requires Node.js');
|
|
603
|
+
}
|
|
600
604
|
return [2 /*return*/, NodeUsbTransport];
|
|
601
605
|
case 2:
|
|
602
606
|
if (env === 'emulator')
|
|
@@ -606,7 +610,10 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
|
|
|
606
610
|
});
|
|
607
611
|
}); };
|
|
608
612
|
var _core;
|
|
613
|
+
var _plugin;
|
|
609
614
|
var _settings = HardwareSdk.parseConnectSettings();
|
|
615
|
+
var lifecycle = Promise.resolve(undefined);
|
|
616
|
+
var pendingInitializations = new Set();
|
|
610
617
|
var usbIdentityProbeTransports = {};
|
|
611
618
|
var usbIdentityProbes = {};
|
|
612
619
|
/** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
|
|
@@ -634,21 +641,26 @@ var probeUsbDeviceIdentities = function (_a) {
|
|
|
634
641
|
var _messageID = 0;
|
|
635
642
|
var messagePromises = {};
|
|
636
643
|
var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
637
|
-
var core;
|
|
638
|
-
|
|
639
|
-
|
|
640
|
-
switch (_b.label) {
|
|
644
|
+
var core, pending, disposing;
|
|
645
|
+
return __generator(this, function (_a) {
|
|
646
|
+
switch (_a.label) {
|
|
641
647
|
case 0:
|
|
642
648
|
core = _core;
|
|
649
|
+
pendingInitializations.forEach(function (controller) { return controller.abort(); });
|
|
650
|
+
pendingInitializations.clear();
|
|
651
|
+
pending = lifecycle.catch(function () { return undefined; });
|
|
643
652
|
_core = undefined;
|
|
653
|
+
_plugin = undefined;
|
|
644
654
|
eventEmitter.removeAllListeners();
|
|
645
655
|
Object.keys(messagePromises).forEach(function (key) {
|
|
646
656
|
delete messagePromises[Number(key)];
|
|
647
657
|
});
|
|
648
658
|
_settings = HardwareSdk.parseConnectSettings();
|
|
649
|
-
|
|
659
|
+
disposing = Promise.all([pending, core === null || core === void 0 ? void 0 : core.dispose()]);
|
|
660
|
+
lifecycle = disposing;
|
|
661
|
+
return [4 /*yield*/, disposing];
|
|
650
662
|
case 1:
|
|
651
|
-
|
|
663
|
+
_a.sent();
|
|
652
664
|
return [2 /*return*/];
|
|
653
665
|
}
|
|
654
666
|
});
|
|
@@ -657,8 +669,9 @@ var uiResponse = function (response) {
|
|
|
657
669
|
if (!_core) {
|
|
658
670
|
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
|
|
659
671
|
}
|
|
660
|
-
|
|
661
|
-
|
|
672
|
+
_core
|
|
673
|
+
.handleMessage(__assign(__assign({}, response), { event: HardwareSdk.UI_EVENT }))
|
|
674
|
+
.catch(function (error) { return Log.error(HardwareSdk.createErrorMessage(error)); });
|
|
662
675
|
};
|
|
663
676
|
var cancel = function (connectId) {
|
|
664
677
|
if (_core === undefined)
|
|
@@ -729,35 +742,71 @@ function postMessage(message, usePromise) {
|
|
|
729
742
|
});
|
|
730
743
|
});
|
|
731
744
|
}
|
|
732
|
-
var init = function (settings, _, plugin) {
|
|
733
|
-
var Transport, error_1;
|
|
745
|
+
var init = function (settings, _, plugin) {
|
|
734
746
|
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
|
-
|
|
747
|
+
_settings = __assign(__assign(__assign({}, _settings), settings), { env: (_a = settings.env) !== null && _a !== void 0 ? _a : 'node' });
|
|
748
|
+
var initSettings = _settings;
|
|
749
|
+
var controller = new AbortController();
|
|
750
|
+
var signal = controller.signal;
|
|
751
|
+
pendingInitializations.add(controller);
|
|
752
|
+
var initialize = function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
753
|
+
var Transport, previous, core, error_1;
|
|
754
|
+
return __generator(this, function (_a) {
|
|
755
|
+
switch (_a.label) {
|
|
756
|
+
case 0:
|
|
757
|
+
if (signal.aborted)
|
|
758
|
+
return [2 /*return*/, false];
|
|
759
|
+
HardwareSdk.enableLog(!!settings.debug);
|
|
760
|
+
Log.debug('init');
|
|
761
|
+
_a.label = 1;
|
|
762
|
+
case 1:
|
|
763
|
+
_a.trys.push([1, 8, , 9]);
|
|
764
|
+
return [4 /*yield*/, getTransport(initSettings.env)];
|
|
765
|
+
case 2:
|
|
766
|
+
Transport = _a.sent();
|
|
767
|
+
if (signal.aborted)
|
|
768
|
+
return [2 /*return*/, false];
|
|
769
|
+
previous = _core;
|
|
770
|
+
_core = undefined;
|
|
771
|
+
_plugin = undefined;
|
|
772
|
+
if (!previous) return [3 /*break*/, 4];
|
|
773
|
+
return [4 /*yield*/, previous.dispose()];
|
|
774
|
+
case 3:
|
|
775
|
+
_a.sent();
|
|
776
|
+
_a.label = 4;
|
|
777
|
+
case 4:
|
|
778
|
+
if (signal.aborted)
|
|
779
|
+
return [2 /*return*/, false];
|
|
780
|
+
return [4 /*yield*/, HardwareSdk.initCore(initSettings, Transport, plugin, signal)];
|
|
781
|
+
case 5:
|
|
782
|
+
core = _a.sent();
|
|
783
|
+
if (!core)
|
|
784
|
+
return [2 /*return*/, false];
|
|
785
|
+
if (!signal.aborted) return [3 /*break*/, 7];
|
|
786
|
+
return [4 /*yield*/, core.dispose()];
|
|
787
|
+
case 6:
|
|
788
|
+
_a.sent();
|
|
789
|
+
return [2 /*return*/, false];
|
|
790
|
+
case 7:
|
|
791
|
+
_core = core;
|
|
792
|
+
_plugin = plugin;
|
|
793
|
+
core.on(HardwareSdk.CORE_EVENT, handleMessage);
|
|
794
|
+
HardwareSdk.setLoggerPostMessage(handleMessage);
|
|
795
|
+
return [2 /*return*/, true];
|
|
796
|
+
case 8:
|
|
797
|
+
error_1 = _a.sent();
|
|
798
|
+
Log.error(HardwareSdk.createErrorMessage(error_1));
|
|
799
|
+
return [2 /*return*/, false];
|
|
800
|
+
case 9: return [2 /*return*/];
|
|
801
|
+
}
|
|
802
|
+
});
|
|
803
|
+
}); };
|
|
804
|
+
var initializing = lifecycle.then(initialize, initialize).finally(function () {
|
|
805
|
+
pendingInitializations.delete(controller);
|
|
759
806
|
});
|
|
760
|
-
|
|
807
|
+
lifecycle = initializing;
|
|
808
|
+
return initializing;
|
|
809
|
+
};
|
|
761
810
|
var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
|
|
762
811
|
var blockLog, response, error_2;
|
|
763
812
|
var _a, _b, _c, _d;
|
|
@@ -801,6 +850,65 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
|
|
|
801
850
|
}); };
|
|
802
851
|
var updateSettings = function () { return Promise.resolve(true); };
|
|
803
852
|
var switchTransport = function () { return Promise.resolve({ success: true }); };
|
|
853
|
+
var addHardwareGlobalEventListener = function (listener) {
|
|
854
|
+
[
|
|
855
|
+
HardwareSdk.UI_EVENT,
|
|
856
|
+
HardwareSdk.LOG_EVENT,
|
|
857
|
+
HardwareSdk.FIRMWARE_EVENT,
|
|
858
|
+
HardwareSdk.DEVICE.CONNECT,
|
|
859
|
+
HardwareSdk.DEVICE.DISCONNECT,
|
|
860
|
+
HardwareSdk.DEVICE.FEATURES,
|
|
861
|
+
HardwareSdk.DEVICE.STATE,
|
|
862
|
+
HardwareSdk.DEVICE.SUPPORT_FEATURES,
|
|
863
|
+
].forEach(function (eventName) {
|
|
864
|
+
eventEmitter.on(eventName, function (message) {
|
|
865
|
+
// Match the Web SDK envelope for device events emitted as payloads.
|
|
866
|
+
var envelope = message;
|
|
867
|
+
var emitMessage = message;
|
|
868
|
+
if (!envelope.event && !envelope.type) {
|
|
869
|
+
emitMessage = __assign({}, message);
|
|
870
|
+
Object.assign(emitMessage, { event: eventName, type: eventName });
|
|
871
|
+
}
|
|
872
|
+
listener(emitMessage);
|
|
873
|
+
});
|
|
874
|
+
});
|
|
875
|
+
};
|
|
876
|
+
var HardwareSDKLowLevel = HardwareSdk.HardwareSDKLowLevel({
|
|
877
|
+
eventEmitter: eventEmitter,
|
|
878
|
+
init: function (settings, sdk, plugin) { return init(__assign(__assign({}, _settings), settings), sdk, plugin); },
|
|
879
|
+
call: call,
|
|
880
|
+
cancel: cancel,
|
|
881
|
+
dispose: dispose,
|
|
882
|
+
addHardwareGlobalEventListener: addHardwareGlobalEventListener,
|
|
883
|
+
uiResponse: uiResponse,
|
|
884
|
+
updateSettings: function (settings) {
|
|
885
|
+
if (_core || pendingInitializations.size > 0) {
|
|
886
|
+
return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.IFrameAleradyInitialized));
|
|
887
|
+
}
|
|
888
|
+
_settings = HardwareSdk.parseConnectSettings(__assign(__assign({}, _settings), settings));
|
|
889
|
+
return Promise.resolve(true);
|
|
890
|
+
},
|
|
891
|
+
switchTransport: function (env) { return __awaiter(void 0, void 0, void 0, function () {
|
|
892
|
+
var owner;
|
|
893
|
+
return __generator(this, function (_a) {
|
|
894
|
+
switch (_a.label) {
|
|
895
|
+
case 0:
|
|
896
|
+
owner = _core;
|
|
897
|
+
if (!owner)
|
|
898
|
+
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
|
|
899
|
+
return [4 /*yield*/, HardwareSdk.switchTransport({
|
|
900
|
+
env: env,
|
|
901
|
+
owner: owner,
|
|
902
|
+
loadTransport: function () { return getTransport(env); },
|
|
903
|
+
plugin: _plugin,
|
|
904
|
+
})];
|
|
905
|
+
case 1:
|
|
906
|
+
_a.sent();
|
|
907
|
+
return [2 /*return*/, { success: true, payload: {} }];
|
|
908
|
+
}
|
|
909
|
+
});
|
|
910
|
+
}); },
|
|
911
|
+
});
|
|
804
912
|
var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
|
|
805
913
|
eventEmitter: eventEmitter,
|
|
806
914
|
init: init,
|
|
@@ -812,6 +920,7 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
|
|
|
812
920
|
switchTransport: switchTransport,
|
|
813
921
|
});
|
|
814
922
|
|
|
923
|
+
exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
|
|
815
924
|
exports["default"] = HardwareCommonConnectSdk;
|
|
816
925
|
exports.messagePromises = messagePromises;
|
|
817
926
|
exports.probeUsbDeviceIdentities = probeUsbDeviceIdentities;
|
package/package.json
CHANGED
|
@@ -1,10 +1,13 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@onekeyfe/hd-common-connect-sdk",
|
|
3
|
-
"version": "1.2.11-alpha.
|
|
3
|
+
"version": "1.2.11-alpha.6",
|
|
4
4
|
"author": "OneKey",
|
|
5
5
|
"homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
|
|
6
6
|
"license": "ISC",
|
|
7
7
|
"main": "dist/index.js",
|
|
8
|
+
"browser": {
|
|
9
|
+
"@onekeyfe/hd-transport-usb": false
|
|
10
|
+
},
|
|
8
11
|
"types": "dist/index.d.ts",
|
|
9
12
|
"repository": {
|
|
10
13
|
"type": "git",
|
|
@@ -15,19 +18,22 @@
|
|
|
15
18
|
},
|
|
16
19
|
"scripts": {
|
|
17
20
|
"dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
|
|
18
|
-
"build": "rimraf dist && rollup -c ../../build/rollup.config.js",
|
|
21
|
+
"build": "rimraf dist && rollup -c ../../build/rollup.config.js && node scripts/check-bundle.mjs",
|
|
19
22
|
"test": "jest",
|
|
20
23
|
"lint": "eslint .",
|
|
21
24
|
"lint:fix": "eslint . --fix"
|
|
22
25
|
},
|
|
26
|
+
"devDependencies": {
|
|
27
|
+
"esbuild": "^0.27.0"
|
|
28
|
+
},
|
|
23
29
|
"dependencies": {
|
|
24
|
-
"@onekeyfe/hd-core": "1.2.11-alpha.
|
|
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.
|
|
30
|
+
"@onekeyfe/hd-core": "1.2.11-alpha.6",
|
|
31
|
+
"@onekeyfe/hd-shared": "1.2.11-alpha.6",
|
|
32
|
+
"@onekeyfe/hd-transport-emulator": "1.2.11-alpha.6",
|
|
33
|
+
"@onekeyfe/hd-transport-http": "1.2.11-alpha.6",
|
|
34
|
+
"@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.6",
|
|
35
|
+
"@onekeyfe/hd-transport-usb": "1.2.11-alpha.6",
|
|
36
|
+
"@onekeyfe/hd-transport-web-device": "1.2.11-alpha.6"
|
|
31
37
|
},
|
|
32
|
-
"gitHead": "
|
|
38
|
+
"gitHead": "fe0e726cdb7de7d9889e26af1db227d9bed32369"
|
|
33
39
|
}
|
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
import assert from 'node:assert/strict';
|
|
2
|
+
import { fileURLToPath } from 'node:url';
|
|
3
|
+
|
|
4
|
+
import { buildSync } from 'esbuild';
|
|
5
|
+
|
|
6
|
+
const packageDirectory = fileURLToPath(new URL('..', import.meta.url));
|
|
7
|
+
const options = {
|
|
8
|
+
absWorkingDir: packageDirectory,
|
|
9
|
+
stdin: {
|
|
10
|
+
contents: `export { HardwareSDKLowLevel } from '@onekeyfe/hd-common-connect-sdk';`,
|
|
11
|
+
resolveDir: packageDirectory,
|
|
12
|
+
},
|
|
13
|
+
bundle: true,
|
|
14
|
+
format: 'cjs',
|
|
15
|
+
logLevel: 'error',
|
|
16
|
+
metafile: true,
|
|
17
|
+
write: false,
|
|
18
|
+
};
|
|
19
|
+
|
|
20
|
+
const nativeUsbModule = /(?:^|\/)(?:hd-transport-usb|usb|node-gyp-build)\//u;
|
|
21
|
+
const hasNativeUsb = ({ metafile }) =>
|
|
22
|
+
Object.keys(metafile.inputs).some(
|
|
23
|
+
input => !input.startsWith('(disabled):') && nativeUsbModule.test(input)
|
|
24
|
+
);
|
|
25
|
+
|
|
26
|
+
assert.equal(
|
|
27
|
+
hasNativeUsb(buildSync({ ...options, platform: 'browser' })),
|
|
28
|
+
false,
|
|
29
|
+
'Browser bundles must exclude the native USB transport'
|
|
30
|
+
);
|
|
31
|
+
assert.equal(
|
|
32
|
+
hasNativeUsb(buildSync({ ...options, platform: 'node' })),
|
|
33
|
+
true,
|
|
34
|
+
'Node bundles must retain the native USB transport'
|
|
35
|
+
);
|
package/src/index.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import EventEmitter from 'events';
|
|
2
2
|
import HardwareSdk, {
|
|
3
|
+
HardwareSDKLowLevel as HardwareLowLevelSdk,
|
|
3
4
|
CORE_EVENT,
|
|
4
5
|
DEVICE,
|
|
5
6
|
DEVICE_EVENT,
|
|
@@ -19,6 +20,7 @@ import HardwareSdk, {
|
|
|
19
20
|
parseConnectSettings,
|
|
20
21
|
probeUsbDeviceIdentitiesWithTransport,
|
|
21
22
|
setLoggerPostMessage,
|
|
23
|
+
switchTransport as switchCoreTransport,
|
|
22
24
|
} from '@onekeyfe/hd-core';
|
|
23
25
|
import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
|
|
24
26
|
import HttpTransport from '@onekeyfe/hd-transport-http';
|
|
@@ -47,9 +49,14 @@ const getTransport = async (env: ConnectSettings['env']) => {
|
|
|
47
49
|
if (env === 'webusb' || env === 'desktop-webusb') return WebUsbTransport;
|
|
48
50
|
if (env === 'lowlevel') return LowlevelTransport;
|
|
49
51
|
if (env === 'node-usb') {
|
|
50
|
-
// Dynamic import — usb is a native Node.js module (libusb C++ bindings)
|
|
51
|
-
// that cannot be resolved by browser/React Native bundlers
|
|
52
52
|
const { default: NodeUsbTransport } = await import('@onekeyfe/hd-transport-usb');
|
|
53
|
+
// Browser bundlers replace this Node-only package with an empty module.
|
|
54
|
+
if (typeof NodeUsbTransport !== 'function') {
|
|
55
|
+
throw ERRORS.TypedError(
|
|
56
|
+
HardwareErrorCode.TransportNotConfigured,
|
|
57
|
+
'Node USB requires Node.js'
|
|
58
|
+
);
|
|
59
|
+
}
|
|
53
60
|
return NodeUsbTransport;
|
|
54
61
|
}
|
|
55
62
|
if (env === 'emulator') return EmulatorTransport;
|
|
@@ -57,7 +64,10 @@ const getTransport = async (env: ConnectSettings['env']) => {
|
|
|
57
64
|
};
|
|
58
65
|
|
|
59
66
|
let _core: Core | undefined;
|
|
67
|
+
let _plugin: LowlevelTransportSharedPlugin | undefined;
|
|
60
68
|
let _settings = parseConnectSettings();
|
|
69
|
+
let lifecycle = Promise.resolve<unknown>(undefined);
|
|
70
|
+
const pendingInitializations = new Set<AbortController>();
|
|
61
71
|
|
|
62
72
|
const usbIdentityProbeTransports: Partial<Record<UsbDeviceIdentity['commType'], WebUsbTransport>> =
|
|
63
73
|
{};
|
|
@@ -95,21 +105,28 @@ export const messagePromises: { [key: number]: Deferred<any> } = {};
|
|
|
95
105
|
|
|
96
106
|
const dispose = async () => {
|
|
97
107
|
const core = _core;
|
|
108
|
+
pendingInitializations.forEach(controller => controller.abort());
|
|
109
|
+
pendingInitializations.clear();
|
|
110
|
+
const pending = lifecycle.catch(() => undefined);
|
|
98
111
|
_core = undefined;
|
|
112
|
+
_plugin = undefined;
|
|
99
113
|
eventEmitter.removeAllListeners();
|
|
100
114
|
Object.keys(messagePromises).forEach(key => {
|
|
101
115
|
delete messagePromises[Number(key)];
|
|
102
116
|
});
|
|
103
117
|
_settings = parseConnectSettings();
|
|
104
|
-
|
|
118
|
+
const disposing = Promise.all([pending, core?.dispose()]);
|
|
119
|
+
lifecycle = disposing;
|
|
120
|
+
await disposing;
|
|
105
121
|
};
|
|
106
122
|
|
|
107
123
|
const uiResponse = (response: UiResponseEvent) => {
|
|
108
124
|
if (!_core) {
|
|
109
125
|
throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
|
|
110
126
|
}
|
|
111
|
-
|
|
112
|
-
|
|
127
|
+
_core
|
|
128
|
+
.handleMessage({ ...response, event: UI_EVENT } as CoreMessage)
|
|
129
|
+
.catch(error => Log.error(createErrorMessage(error)));
|
|
113
130
|
};
|
|
114
131
|
|
|
115
132
|
const cancel = (connectId?: string) => {
|
|
@@ -177,29 +194,53 @@ async function postMessage(message: CoreMessage, usePromise = true) {
|
|
|
177
194
|
_core.handleMessage(message);
|
|
178
195
|
}
|
|
179
196
|
|
|
180
|
-
const init =
|
|
197
|
+
const init = (
|
|
181
198
|
settings: Partial<ConnectSettings>,
|
|
182
199
|
_?: LowLevelCoreApi,
|
|
183
200
|
plugin?: LowlevelTransportSharedPlugin
|
|
184
201
|
) => {
|
|
185
202
|
_settings = { ..._settings, ...settings, env: settings.env ?? 'node' };
|
|
203
|
+
const initSettings = _settings;
|
|
204
|
+
const controller = new AbortController();
|
|
205
|
+
const { signal } = controller;
|
|
206
|
+
pendingInitializations.add(controller);
|
|
186
207
|
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
208
|
+
const initialize = async () => {
|
|
209
|
+
if (signal.aborted) return false;
|
|
210
|
+
enableLog(!!settings.debug);
|
|
211
|
+
Log.debug('init');
|
|
190
212
|
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
_core?.on(CORE_EVENT, handleMessage);
|
|
195
|
-
setLoggerPostMessage(handleMessage);
|
|
213
|
+
try {
|
|
214
|
+
const Transport = await getTransport(initSettings.env);
|
|
215
|
+
if (signal.aborted) return false;
|
|
196
216
|
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
217
|
+
const previous = _core;
|
|
218
|
+
_core = undefined;
|
|
219
|
+
_plugin = undefined;
|
|
220
|
+
if (previous) await previous.dispose();
|
|
221
|
+
if (signal.aborted) return false;
|
|
222
|
+
const core = await initCore(initSettings, Transport, plugin, signal);
|
|
223
|
+
if (!core) return false;
|
|
224
|
+
if (signal.aborted) {
|
|
225
|
+
await core.dispose();
|
|
226
|
+
return false;
|
|
227
|
+
}
|
|
228
|
+
_core = core;
|
|
229
|
+
_plugin = plugin;
|
|
230
|
+
core.on(CORE_EVENT, handleMessage);
|
|
231
|
+
setLoggerPostMessage(handleMessage);
|
|
232
|
+
return true;
|
|
233
|
+
} catch (error) {
|
|
234
|
+
Log.error(createErrorMessage(error));
|
|
235
|
+
return false;
|
|
236
|
+
}
|
|
237
|
+
};
|
|
200
238
|
|
|
201
|
-
|
|
202
|
-
|
|
239
|
+
const initializing = lifecycle.then(initialize, initialize).finally(() => {
|
|
240
|
+
pendingInitializations.delete(controller);
|
|
241
|
+
});
|
|
242
|
+
lifecycle = initializing;
|
|
243
|
+
return initializing;
|
|
203
244
|
};
|
|
204
245
|
|
|
205
246
|
const call = async (params: any) => {
|
|
@@ -239,6 +280,58 @@ const call = async (params: any) => {
|
|
|
239
280
|
const updateSettings = () => Promise.resolve(true);
|
|
240
281
|
const switchTransport = () => Promise.resolve({ success: true });
|
|
241
282
|
|
|
283
|
+
const addHardwareGlobalEventListener = (listener: (message: CoreMessage) => void) => {
|
|
284
|
+
[
|
|
285
|
+
UI_EVENT,
|
|
286
|
+
LOG_EVENT,
|
|
287
|
+
FIRMWARE_EVENT,
|
|
288
|
+
DEVICE.CONNECT,
|
|
289
|
+
DEVICE.DISCONNECT,
|
|
290
|
+
DEVICE.FEATURES,
|
|
291
|
+
DEVICE.STATE,
|
|
292
|
+
DEVICE.SUPPORT_FEATURES,
|
|
293
|
+
].forEach(eventName => {
|
|
294
|
+
eventEmitter.on(eventName, (message: CoreMessage) => {
|
|
295
|
+
// Match the Web SDK envelope for device events emitted as payloads.
|
|
296
|
+
const envelope: { event?: string; type?: string } = message;
|
|
297
|
+
let emitMessage = message;
|
|
298
|
+
if (!envelope.event && !envelope.type) {
|
|
299
|
+
emitMessage = { ...message };
|
|
300
|
+
Object.assign(emitMessage, { event: eventName, type: eventName });
|
|
301
|
+
}
|
|
302
|
+
listener(emitMessage);
|
|
303
|
+
});
|
|
304
|
+
});
|
|
305
|
+
};
|
|
306
|
+
|
|
307
|
+
export const HardwareSDKLowLevel = HardwareLowLevelSdk({
|
|
308
|
+
eventEmitter,
|
|
309
|
+
init: (settings, sdk, plugin) => init({ ..._settings, ...settings }, sdk, plugin),
|
|
310
|
+
call,
|
|
311
|
+
cancel,
|
|
312
|
+
dispose,
|
|
313
|
+
addHardwareGlobalEventListener,
|
|
314
|
+
uiResponse,
|
|
315
|
+
updateSettings: (settings: Partial<ConnectSettings>) => {
|
|
316
|
+
if (_core || pendingInitializations.size > 0) {
|
|
317
|
+
return Promise.reject(ERRORS.TypedError(HardwareErrorCode.IFrameAleradyInitialized));
|
|
318
|
+
}
|
|
319
|
+
_settings = parseConnectSettings({ ..._settings, ...settings });
|
|
320
|
+
return Promise.resolve(true);
|
|
321
|
+
},
|
|
322
|
+
switchTransport: async (env: ConnectSettings['env']) => {
|
|
323
|
+
const owner = _core;
|
|
324
|
+
if (!owner) throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
|
|
325
|
+
await switchCoreTransport({
|
|
326
|
+
env,
|
|
327
|
+
owner,
|
|
328
|
+
loadTransport: () => getTransport(env),
|
|
329
|
+
plugin: _plugin,
|
|
330
|
+
});
|
|
331
|
+
return { success: true, payload: {} };
|
|
332
|
+
},
|
|
333
|
+
});
|
|
334
|
+
|
|
242
335
|
const HardwareCommonConnectSdk = HardwareSdk({
|
|
243
336
|
eventEmitter,
|
|
244
337
|
init,
|