@onekeyfe/hd-common-connect-sdk 1.2.8 → 1.2.10-alpha.2
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 +27 -0
- package/__tests__/device-state-events.test.ts +62 -5
- package/__tests__/direct-lowlevel.test.js +103 -0
- package/dist/index.d.ts +7 -1
- package/dist/index.js +95 -7
- package/package.json +9 -9
- package/src/index.ts +89 -0
package/README.md
CHANGED
|
@@ -28,6 +28,33 @@ function init() {
|
|
|
28
28
|
}
|
|
29
29
|
```
|
|
30
30
|
|
|
31
|
+
## Desktop USB identity discovery
|
|
32
|
+
|
|
33
|
+
`probeUsbDeviceIdentities({ commType: 'webusb' | 'bridge' })` is a named export for
|
|
34
|
+
choosing a Desktop connection before switching the active SDK. It does not require
|
|
35
|
+
SDK initialization, dispose Core, change BLE settings, or open a wallet session.
|
|
36
|
+
Concurrent probes for the same mode share one pending request.
|
|
37
|
+
|
|
38
|
+
```typescript
|
|
39
|
+
import { probeUsbDeviceIdentities } from '@onekeyfe/hd-common-connect-sdk';
|
|
40
|
+
|
|
41
|
+
const devices = await probeUsbDeviceIdentities({ commType: 'webusb' });
|
|
42
|
+
```
|
|
43
|
+
|
|
44
|
+
Each result contains `path`, `serialNo`, `deviceId`, `deviceType`, `connectProtocol`,
|
|
45
|
+
and `commType`. `path` locates the USB endpoint; compare `serialNo` with the target's
|
|
46
|
+
physical identity, or `deviceId` for legacy devices without a physical serial.
|
|
47
|
+
Missing identities remain `null`; a descriptor path is never substituted for them.
|
|
48
|
+
The protocol comes from an active device response. V1 uses read-only Features;
|
|
49
|
+
V2 uses hardware DeviceInfo and does not query a wallet session.
|
|
50
|
+
|
|
51
|
+
Busy, ambiguous, disconnected, or unverified endpoints are omitted. An active
|
|
52
|
+
WebUSB request's identity can be reused only for the exact USB handle it owns.
|
|
53
|
+
Discovery releases only handles it acquired and does not replace the active SDK's
|
|
54
|
+
disconnect observer. An empty result is not proof that the device is absent.
|
|
55
|
+
Keep the selected transport fixed during a hardware operation; reevaluate it
|
|
56
|
+
between operations. Firmware updates must separately validate their live target.
|
|
57
|
+
|
|
31
58
|
## Docs
|
|
32
59
|
|
|
33
60
|
Documentation is available [Hardware SDK Getting Started](https://developer.onekey.so/en/hardware-sdk/getting-started)
|
|
@@ -1,10 +1,16 @@
|
|
|
1
1
|
import { readFileSync } from 'fs';
|
|
2
2
|
import { resolve } from 'path';
|
|
3
3
|
import EventEmitter from 'events';
|
|
4
|
-
import {
|
|
5
|
-
|
|
4
|
+
import {
|
|
5
|
+
CORE_EVENT,
|
|
6
|
+
UI_REQUEST,
|
|
7
|
+
initCore,
|
|
8
|
+
probeUsbDeviceIdentitiesWithTransport,
|
|
9
|
+
} from '@onekeyfe/hd-core';
|
|
10
|
+
import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
|
|
11
|
+
import HttpTransport from '@onekeyfe/hd-transport-http';
|
|
6
12
|
|
|
7
|
-
import sdkExport, { messagePromises } from '../src';
|
|
13
|
+
import sdkExport, { messagePromises, probeUsbDeviceIdentities } from '../src';
|
|
8
14
|
|
|
9
15
|
jest.mock('../../core/src/data/config', () => ({
|
|
10
16
|
getSDKVersion: jest.fn(() => '1.0.0-test'),
|
|
@@ -15,9 +21,10 @@ jest.mock('@onekeyfe/hd-core', () => ({
|
|
|
15
21
|
__esModule: true,
|
|
16
22
|
default: (options: unknown) => options,
|
|
17
23
|
initCore: jest.fn(),
|
|
24
|
+
probeUsbDeviceIdentitiesWithTransport: jest.fn(),
|
|
18
25
|
}));
|
|
19
|
-
jest.mock('@onekeyfe/hd-transport-http', () => ({}));
|
|
20
|
-
jest.mock('@onekeyfe/hd-transport-web-device', () => ({}));
|
|
26
|
+
jest.mock('@onekeyfe/hd-transport-http', () => ({ __esModule: true, default: jest.fn() }));
|
|
27
|
+
jest.mock('@onekeyfe/hd-transport-web-device', () => ({ WebUsbTransport: jest.fn() }));
|
|
21
28
|
jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
|
|
22
29
|
jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
|
|
23
30
|
|
|
@@ -56,6 +63,17 @@ describe('SDK request cleanup', () => {
|
|
|
56
63
|
await sdk.dispose();
|
|
57
64
|
});
|
|
58
65
|
|
|
66
|
+
test.each([
|
|
67
|
+
[HardwareErrorCode.BlePoweredOff, UI_REQUEST.BLUETOOTH_POWERED_OFF],
|
|
68
|
+
[HardwareErrorCode.BleUnsupported, UI_REQUEST.BLUETOOTH_UNSUPPORTED],
|
|
69
|
+
[HardwareErrorCode.BleLocationError, UI_REQUEST.LOCATION_PERMISSION],
|
|
70
|
+
])('emits the adapter UI request for error %s', async (code, type) => {
|
|
71
|
+
const response = { success: false, payload: { code, error: 'Adapter unavailable' } };
|
|
72
|
+
core.handleMessage.mockResolvedValueOnce(response);
|
|
73
|
+
await expect(sdk.call({ method: 'searchDevices' })).resolves.toEqual(response);
|
|
74
|
+
expect(core.handleMessage).toHaveBeenNthCalledWith(2, expect.objectContaining({ type }));
|
|
75
|
+
});
|
|
76
|
+
|
|
59
77
|
test('removes only the completed request when calls settle out of order', async () => {
|
|
60
78
|
const first = createDeferred<unknown>();
|
|
61
79
|
const second = createDeferred<unknown>();
|
|
@@ -71,6 +89,45 @@ describe('SDK request cleanup', () => {
|
|
|
71
89
|
expect(Object.keys(messagePromises)).toHaveLength(0);
|
|
72
90
|
});
|
|
73
91
|
|
|
92
|
+
test.each(['webusb'] as const)(
|
|
93
|
+
'probes %s without disposing an outstanding BLE request and coalesces concurrent probes',
|
|
94
|
+
async commType => {
|
|
95
|
+
const pending = createDeferred<unknown>();
|
|
96
|
+
const discovery = createDeferred<never[]>();
|
|
97
|
+
core.handleMessage.mockReturnValueOnce(pending.promise);
|
|
98
|
+
const request = sdk.call({ method: 'getDeviceState' });
|
|
99
|
+
jest
|
|
100
|
+
.mocked(probeUsbDeviceIdentitiesWithTransport)
|
|
101
|
+
.mockReset()
|
|
102
|
+
.mockReturnValueOnce(discovery.promise);
|
|
103
|
+
const initializationCount = jest.mocked(initCore).mock.calls.length;
|
|
104
|
+
const first = probeUsbDeviceIdentities({ commType });
|
|
105
|
+
const second = probeUsbDeviceIdentities({ commType });
|
|
106
|
+
expect(second).toBe(first);
|
|
107
|
+
expect(probeUsbDeviceIdentitiesWithTransport).toHaveBeenCalledTimes(1);
|
|
108
|
+
discovery.resolve([]);
|
|
109
|
+
await first;
|
|
110
|
+
expect(core.dispose).not.toHaveBeenCalled();
|
|
111
|
+
expect(initCore).toHaveBeenCalledTimes(initializationCount);
|
|
112
|
+
expect(core.listenerCount(CORE_EVENT)).toBe(1);
|
|
113
|
+
expect(Object.keys(messagePromises)).toHaveLength(1);
|
|
114
|
+
pending.resolve({ success: true, payload: {} });
|
|
115
|
+
await expect(request).resolves.toMatchObject({ success: true });
|
|
116
|
+
expect(Object.keys(messagePromises)).toHaveLength(0);
|
|
117
|
+
}
|
|
118
|
+
);
|
|
119
|
+
|
|
120
|
+
test('rejects the withdrawn Bridge probe without creating a transport or affecting BLE', async () => {
|
|
121
|
+
jest.mocked(HttpTransport).mockClear();
|
|
122
|
+
jest.mocked(probeUsbDeviceIdentitiesWithTransport).mockClear();
|
|
123
|
+
await expect(probeUsbDeviceIdentities({ commType: 'bridge' })).rejects.toMatchObject({
|
|
124
|
+
errorCode: HardwareErrorCode.CallMethodInvalidParameter,
|
|
125
|
+
});
|
|
126
|
+
expect(HttpTransport).not.toHaveBeenCalled();
|
|
127
|
+
expect(probeUsbDeviceIdentitiesWithTransport).not.toHaveBeenCalled();
|
|
128
|
+
expect(core.dispose).not.toHaveBeenCalled();
|
|
129
|
+
});
|
|
130
|
+
|
|
74
131
|
test('waits for Core disposal and does not retain old listeners after reinitialization', async () => {
|
|
75
132
|
const cleanup = createDeferred<void>();
|
|
76
133
|
core.dispose.mockImplementationOnce(async () => {
|
|
@@ -0,0 +1,103 @@
|
|
|
1
|
+
import EventEmitter from 'events';
|
|
2
|
+
import {
|
|
3
|
+
CORE_EVENT,
|
|
4
|
+
DEVICE,
|
|
5
|
+
DEVICE_EVENT,
|
|
6
|
+
UI_EVENT,
|
|
7
|
+
UI_REQUEST,
|
|
8
|
+
IFRAME,
|
|
9
|
+
initCore,
|
|
10
|
+
switchTransport,
|
|
11
|
+
} from '@onekeyfe/hd-core';
|
|
12
|
+
|
|
13
|
+
import { HardwareSDKLowLevel } from '../src';
|
|
14
|
+
|
|
15
|
+
jest.mock('../../core/src/data/config', () => ({
|
|
16
|
+
getSDKVersion: jest.fn(() => '1.0.0-test'),
|
|
17
|
+
DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
|
|
18
|
+
}));
|
|
19
|
+
jest.mock('@onekeyfe/hd-core', () => ({
|
|
20
|
+
__esModule: true,
|
|
21
|
+
...jest.requireActual('@onekeyfe/hd-core'),
|
|
22
|
+
initCore: jest.fn(),
|
|
23
|
+
switchTransport: jest.fn(),
|
|
24
|
+
}));
|
|
25
|
+
jest.mock('@onekeyfe/hd-transport-http', () => ({}));
|
|
26
|
+
jest.mock('@onekeyfe/hd-transport-web-device', () => ({ WebUsbTransport: {} }));
|
|
27
|
+
jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
|
|
28
|
+
jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
|
|
29
|
+
|
|
30
|
+
const core = Object.assign(new EventEmitter(), {
|
|
31
|
+
handleMessage: jest.fn(),
|
|
32
|
+
dispose: jest.fn(() => {
|
|
33
|
+
core.removeAllListeners();
|
|
34
|
+
return Promise.resolve();
|
|
35
|
+
}),
|
|
36
|
+
});
|
|
37
|
+
|
|
38
|
+
beforeEach(() => {
|
|
39
|
+
jest.clearAllMocks();
|
|
40
|
+
initCore.mockResolvedValue(core);
|
|
41
|
+
});
|
|
42
|
+
afterEach(async () => HardwareSDKLowLevel.dispose());
|
|
43
|
+
|
|
44
|
+
test('initializes, calls and switches the local Core without a DOM or iframe', async () => {
|
|
45
|
+
expect(typeof document).toBe('undefined');
|
|
46
|
+
expect(await HardwareSDKLowLevel.init({ env: 'webusb' })).toBe(true);
|
|
47
|
+
expect(initCore).toHaveBeenCalledWith(
|
|
48
|
+
expect.objectContaining({ env: 'webusb' }),
|
|
49
|
+
expect.anything(),
|
|
50
|
+
undefined
|
|
51
|
+
);
|
|
52
|
+
const response = { success: true, payload: { test: true } };
|
|
53
|
+
core.handleMessage.mockResolvedValue(response);
|
|
54
|
+
expect(await HardwareSDKLowLevel.call({ method: 'getFeatures' })).toBe(response);
|
|
55
|
+
expect(core.handleMessage).toHaveBeenCalledWith(
|
|
56
|
+
expect.objectContaining({
|
|
57
|
+
event: IFRAME.CALL,
|
|
58
|
+
type: IFRAME.CALL,
|
|
59
|
+
payload: expect.objectContaining({ method: 'getFeatures' }),
|
|
60
|
+
})
|
|
61
|
+
);
|
|
62
|
+
expect(await HardwareSDKLowLevel.switchTransport('webusb')).toStrictEqual({
|
|
63
|
+
success: true,
|
|
64
|
+
payload: {},
|
|
65
|
+
});
|
|
66
|
+
expect(switchTransport).toHaveBeenCalledWith({
|
|
67
|
+
env: 'webusb',
|
|
68
|
+
Transport: expect.anything(),
|
|
69
|
+
plugin: undefined,
|
|
70
|
+
});
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
test('keeps the Web LowLevel event envelope and cleans listeners on dispose', async () => {
|
|
74
|
+
const listener = jest.fn();
|
|
75
|
+
HardwareSDKLowLevel.addHardwareGlobalEventListener(listener);
|
|
76
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
77
|
+
const payload = { device: { label: 'Synthetic device' } };
|
|
78
|
+
core.emit(CORE_EVENT, { event: DEVICE_EVENT, type: DEVICE.CONNECT, payload });
|
|
79
|
+
expect(listener).toHaveBeenLastCalledWith({
|
|
80
|
+
...payload,
|
|
81
|
+
event: DEVICE.CONNECT,
|
|
82
|
+
type: DEVICE.CONNECT,
|
|
83
|
+
});
|
|
84
|
+
const message = { event: UI_EVENT, type: UI_REQUEST.REQUEST_BUTTON, payload: {} };
|
|
85
|
+
core.emit(CORE_EVENT, message);
|
|
86
|
+
expect(listener).toHaveBeenLastCalledWith(message);
|
|
87
|
+
await HardwareSDKLowLevel.dispose();
|
|
88
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
89
|
+
listener.mockClear();
|
|
90
|
+
core.emit(CORE_EVENT, message);
|
|
91
|
+
expect(listener).not.toHaveBeenCalled();
|
|
92
|
+
expect(core.listenerCount(CORE_EVENT)).toBe(1);
|
|
93
|
+
});
|
|
94
|
+
|
|
95
|
+
test('uses settings staged before initialization', async () => {
|
|
96
|
+
await HardwareSDKLowLevel.updateSettings({ env: 'webusb' });
|
|
97
|
+
await HardwareSDKLowLevel.init({ debug: false });
|
|
98
|
+
expect(initCore).toHaveBeenCalledWith(
|
|
99
|
+
expect.objectContaining({ env: 'webusb' }),
|
|
100
|
+
expect.anything(),
|
|
101
|
+
undefined
|
|
102
|
+
);
|
|
103
|
+
});
|
package/dist/index.d.ts
CHANGED
|
@@ -1,9 +1,15 @@
|
|
|
1
1
|
import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
|
|
2
|
+
import { UsbDeviceIdentity, LowLevelCoreApi } from '@onekeyfe/hd-core';
|
|
2
3
|
import { Deferred } from '@onekeyfe/hd-shared';
|
|
3
4
|
|
|
5
|
+
/** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
|
|
6
|
+
declare const probeUsbDeviceIdentities: ({ commType, }: {
|
|
7
|
+
commType: UsbDeviceIdentity['commType'];
|
|
8
|
+
}) => Promise<UsbDeviceIdentity[]>;
|
|
4
9
|
declare const messagePromises: {
|
|
5
10
|
[key: number]: Deferred<any>;
|
|
6
11
|
};
|
|
12
|
+
declare const HardwareSDKLowLevel: LowLevelCoreApi;
|
|
7
13
|
declare const HardwareCommonConnectSdk: _onekeyfe_hd_core.CoreApi;
|
|
8
14
|
|
|
9
|
-
export { HardwareCommonConnectSdk as default, messagePromises };
|
|
15
|
+
export { HardwareSDKLowLevel, HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
|
package/dist/index.js
CHANGED
|
@@ -606,7 +606,32 @@ 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 usbIdentityProbeTransports = {};
|
|
612
|
+
var usbIdentityProbes = {};
|
|
613
|
+
/** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
|
|
614
|
+
var probeUsbDeviceIdentities = function (_a) {
|
|
615
|
+
var commType = _a.commType;
|
|
616
|
+
if (commType !== 'webusb') {
|
|
617
|
+
return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter));
|
|
618
|
+
}
|
|
619
|
+
var pending = usbIdentityProbes[commType];
|
|
620
|
+
if (pending)
|
|
621
|
+
return pending;
|
|
622
|
+
var transport = usbIdentityProbeTransports[commType];
|
|
623
|
+
if (!transport) {
|
|
624
|
+
transport = new hdTransportWebDevice.WebUsbTransport(true);
|
|
625
|
+
usbIdentityProbeTransports[commType] = transport;
|
|
626
|
+
}
|
|
627
|
+
var probe = HardwareSdk.probeUsbDeviceIdentitiesWithTransport(transport, commType, function (descriptor) {
|
|
628
|
+
return _core === null || _core === void 0 ? void 0 : _core.getOwnedUsbDeviceIdentity(descriptor);
|
|
629
|
+
}).finally(function () {
|
|
630
|
+
delete usbIdentityProbes[commType];
|
|
631
|
+
});
|
|
632
|
+
usbIdentityProbes[commType] = probe;
|
|
633
|
+
return probe;
|
|
634
|
+
};
|
|
610
635
|
var _messageID = 0;
|
|
611
636
|
var messagePromises = {};
|
|
612
637
|
var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
@@ -617,6 +642,7 @@ var dispose = function () { return __awaiter(void 0, void 0, void 0, function ()
|
|
|
617
642
|
case 0:
|
|
618
643
|
core = _core;
|
|
619
644
|
_core = undefined;
|
|
645
|
+
_plugin = undefined;
|
|
620
646
|
eventEmitter.removeAllListeners();
|
|
621
647
|
Object.keys(messagePromises).forEach(function (key) {
|
|
622
648
|
delete messagePromises[Number(key)];
|
|
@@ -723,6 +749,7 @@ var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, voi
|
|
|
723
749
|
return [4 /*yield*/, HardwareSdk.initCore(_settings, Transport, plugin)];
|
|
724
750
|
case 3:
|
|
725
751
|
_core = _b.sent();
|
|
752
|
+
_plugin = plugin;
|
|
726
753
|
_core === null || _core === void 0 ? void 0 : _core.on(HardwareSdk.CORE_EVENT, handleMessage);
|
|
727
754
|
HardwareSdk.setLoggerPostMessage(handleMessage);
|
|
728
755
|
return [2 /*return*/, true];
|
|
@@ -736,18 +763,18 @@ var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, voi
|
|
|
736
763
|
}); };
|
|
737
764
|
var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
|
|
738
765
|
var blockLog, response, error_2;
|
|
739
|
-
var _a, _b, _c;
|
|
740
|
-
return __generator(this, function (
|
|
741
|
-
switch (
|
|
766
|
+
var _a, _b, _c, _d;
|
|
767
|
+
return __generator(this, function (_e) {
|
|
768
|
+
switch (_e.label) {
|
|
742
769
|
case 0:
|
|
743
770
|
blockLog = HardwareSdk.getLogBlockLabel(params);
|
|
744
771
|
Log.debug('call: ', blockLog !== null && blockLog !== void 0 ? blockLog : params);
|
|
745
|
-
|
|
772
|
+
_e.label = 1;
|
|
746
773
|
case 1:
|
|
747
|
-
|
|
774
|
+
_e.trys.push([1, 3, , 4]);
|
|
748
775
|
return [4 /*yield*/, postMessage({ event: HardwareSdk.IFRAME.CALL, type: HardwareSdk.IFRAME.CALL, payload: params })];
|
|
749
776
|
case 2:
|
|
750
|
-
response =
|
|
777
|
+
response = _e.sent();
|
|
751
778
|
if (response) {
|
|
752
779
|
Log.debug('response: ', blockLog ? '[REDACTED]' : response);
|
|
753
780
|
if (!response.success) {
|
|
@@ -760,12 +787,15 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
|
|
|
760
787
|
if (((_c = response.payload) === null || _c === void 0 ? void 0 : _c.code) === hdShared.HardwareErrorCode.BlePermissionError) {
|
|
761
788
|
postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_PERMISSION), false);
|
|
762
789
|
}
|
|
790
|
+
if (((_d = response.payload) === null || _d === void 0 ? void 0 : _d.code) === hdShared.HardwareErrorCode.BleLocationError) {
|
|
791
|
+
postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.LOCATION_PERMISSION), false);
|
|
792
|
+
}
|
|
763
793
|
}
|
|
764
794
|
return [2 /*return*/, response];
|
|
765
795
|
}
|
|
766
796
|
return [2 /*return*/, HardwareSdk.createErrorMessage(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodNotResponse))];
|
|
767
797
|
case 3:
|
|
768
|
-
error_2 =
|
|
798
|
+
error_2 = _e.sent();
|
|
769
799
|
Log.error('__call error: ', error_2);
|
|
770
800
|
return [2 /*return*/, HardwareSdk.createErrorMessage(error_2)];
|
|
771
801
|
case 4: return [2 /*return*/];
|
|
@@ -774,6 +804,62 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
|
|
|
774
804
|
}); };
|
|
775
805
|
var updateSettings = function () { return Promise.resolve(true); };
|
|
776
806
|
var switchTransport = function () { return Promise.resolve({ success: true }); };
|
|
807
|
+
var addHardwareGlobalEventListener = function (listener) {
|
|
808
|
+
[
|
|
809
|
+
HardwareSdk.UI_EVENT,
|
|
810
|
+
HardwareSdk.LOG_EVENT,
|
|
811
|
+
HardwareSdk.FIRMWARE_EVENT,
|
|
812
|
+
HardwareSdk.DEVICE.CONNECT,
|
|
813
|
+
HardwareSdk.DEVICE.DISCONNECT,
|
|
814
|
+
HardwareSdk.DEVICE.FEATURES,
|
|
815
|
+
HardwareSdk.DEVICE.STATE,
|
|
816
|
+
HardwareSdk.DEVICE.SUPPORT_FEATURES,
|
|
817
|
+
HardwareSdk.UI_REQUEST.FIRMWARE_PROGRESS,
|
|
818
|
+
HardwareSdk.UI_REQUEST.FIRMWARE_TIP,
|
|
819
|
+
HardwareSdk.UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
|
|
820
|
+
].forEach(function (eventName) {
|
|
821
|
+
eventEmitter.on(eventName, function (message) {
|
|
822
|
+
// Match the Web SDK envelope for device events emitted as payloads.
|
|
823
|
+
var envelope = message;
|
|
824
|
+
var emitMessage = message;
|
|
825
|
+
if (!envelope.event && !envelope.type) {
|
|
826
|
+
emitMessage = __assign({}, message);
|
|
827
|
+
Object.assign(emitMessage, { event: eventName, type: eventName });
|
|
828
|
+
}
|
|
829
|
+
listener(emitMessage);
|
|
830
|
+
});
|
|
831
|
+
});
|
|
832
|
+
};
|
|
833
|
+
var HardwareSDKLowLevel = HardwareSdk.HardwareSDKLowLevel({
|
|
834
|
+
eventEmitter: eventEmitter,
|
|
835
|
+
init: function (settings, sdk, plugin) { return init(__assign(__assign({}, _settings), settings), sdk, plugin); },
|
|
836
|
+
call: call,
|
|
837
|
+
cancel: cancel,
|
|
838
|
+
dispose: dispose,
|
|
839
|
+
addHardwareGlobalEventListener: addHardwareGlobalEventListener,
|
|
840
|
+
uiResponse: uiResponse,
|
|
841
|
+
updateSettings: function (settings) {
|
|
842
|
+
if (_core)
|
|
843
|
+
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.IFrameAleradyInitialized);
|
|
844
|
+
_settings = HardwareSdk.parseConnectSettings(__assign(__assign({}, _settings), settings));
|
|
845
|
+
return Promise.resolve(true);
|
|
846
|
+
},
|
|
847
|
+
switchTransport: function (env) { return __awaiter(void 0, void 0, void 0, function () {
|
|
848
|
+
var Transport;
|
|
849
|
+
return __generator(this, function (_a) {
|
|
850
|
+
switch (_a.label) {
|
|
851
|
+
case 0:
|
|
852
|
+
if (!_core)
|
|
853
|
+
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
|
|
854
|
+
return [4 /*yield*/, getTransport(env)];
|
|
855
|
+
case 1:
|
|
856
|
+
Transport = _a.sent();
|
|
857
|
+
HardwareSdk.switchTransport({ env: env, Transport: Transport, plugin: _plugin });
|
|
858
|
+
return [2 /*return*/, { success: true, payload: {} }];
|
|
859
|
+
}
|
|
860
|
+
});
|
|
861
|
+
}); },
|
|
862
|
+
});
|
|
777
863
|
var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
|
|
778
864
|
eventEmitter: eventEmitter,
|
|
779
865
|
init: init,
|
|
@@ -785,5 +871,7 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
|
|
|
785
871
|
switchTransport: switchTransport,
|
|
786
872
|
});
|
|
787
873
|
|
|
874
|
+
exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
|
|
788
875
|
exports["default"] = HardwareCommonConnectSdk;
|
|
789
876
|
exports.messagePromises = messagePromises;
|
|
877
|
+
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.
|
|
3
|
+
"version": "1.2.10-alpha.2",
|
|
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.
|
|
25
|
-
"@onekeyfe/hd-shared": "1.2.
|
|
26
|
-
"@onekeyfe/hd-transport-emulator": "1.2.
|
|
27
|
-
"@onekeyfe/hd-transport-http": "1.2.
|
|
28
|
-
"@onekeyfe/hd-transport-lowlevel": "1.2.
|
|
29
|
-
"@onekeyfe/hd-transport-usb": "1.2.
|
|
30
|
-
"@onekeyfe/hd-transport-web-device": "1.2.
|
|
24
|
+
"@onekeyfe/hd-core": "1.2.10-alpha.2",
|
|
25
|
+
"@onekeyfe/hd-shared": "1.2.10-alpha.2",
|
|
26
|
+
"@onekeyfe/hd-transport-emulator": "1.2.10-alpha.2",
|
|
27
|
+
"@onekeyfe/hd-transport-http": "1.2.10-alpha.2",
|
|
28
|
+
"@onekeyfe/hd-transport-lowlevel": "1.2.10-alpha.2",
|
|
29
|
+
"@onekeyfe/hd-transport-usb": "1.2.10-alpha.2",
|
|
30
|
+
"@onekeyfe/hd-transport-web-device": "1.2.10-alpha.2"
|
|
31
31
|
},
|
|
32
|
-
"gitHead": "
|
|
32
|
+
"gitHead": "2bcc72a43379abb005405f18f914330f3f2dbfd7"
|
|
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,
|
|
@@ -17,7 +18,9 @@ import HardwareSdk, {
|
|
|
17
18
|
getLogger,
|
|
18
19
|
initCore,
|
|
19
20
|
parseConnectSettings,
|
|
21
|
+
probeUsbDeviceIdentitiesWithTransport,
|
|
20
22
|
setLoggerPostMessage,
|
|
23
|
+
switchTransport as switchCoreTransport,
|
|
21
24
|
} from '@onekeyfe/hd-core';
|
|
22
25
|
import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
|
|
23
26
|
import HttpTransport from '@onekeyfe/hd-transport-http';
|
|
@@ -32,6 +35,7 @@ import type {
|
|
|
32
35
|
CoreMessage,
|
|
33
36
|
LowLevelCoreApi,
|
|
34
37
|
UiResponseEvent,
|
|
38
|
+
UsbDeviceIdentity,
|
|
35
39
|
} from '@onekeyfe/hd-core';
|
|
36
40
|
import type { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
|
|
37
41
|
|
|
@@ -55,14 +59,47 @@ const getTransport = async (env: ConnectSettings['env']) => {
|
|
|
55
59
|
};
|
|
56
60
|
|
|
57
61
|
let _core: Core | undefined;
|
|
62
|
+
let _plugin: LowlevelTransportSharedPlugin | undefined;
|
|
58
63
|
let _settings = parseConnectSettings();
|
|
59
64
|
|
|
65
|
+
const usbIdentityProbeTransports: Partial<Record<UsbDeviceIdentity['commType'], WebUsbTransport>> =
|
|
66
|
+
{};
|
|
67
|
+
const usbIdentityProbes: Partial<
|
|
68
|
+
Record<UsbDeviceIdentity['commType'], Promise<UsbDeviceIdentity[]>>
|
|
69
|
+
> = {};
|
|
70
|
+
|
|
71
|
+
/** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
|
|
72
|
+
export const probeUsbDeviceIdentities = ({
|
|
73
|
+
commType,
|
|
74
|
+
}: {
|
|
75
|
+
commType: UsbDeviceIdentity['commType'];
|
|
76
|
+
}): Promise<UsbDeviceIdentity[]> => {
|
|
77
|
+
if (commType !== 'webusb') {
|
|
78
|
+
return Promise.reject(ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter));
|
|
79
|
+
}
|
|
80
|
+
const pending = usbIdentityProbes[commType];
|
|
81
|
+
if (pending) return pending;
|
|
82
|
+
let transport = usbIdentityProbeTransports[commType];
|
|
83
|
+
if (!transport) {
|
|
84
|
+
transport = new WebUsbTransport(true);
|
|
85
|
+
usbIdentityProbeTransports[commType] = transport;
|
|
86
|
+
}
|
|
87
|
+
const probe = probeUsbDeviceIdentitiesWithTransport(transport, commType, descriptor =>
|
|
88
|
+
_core?.getOwnedUsbDeviceIdentity(descriptor)
|
|
89
|
+
).finally(() => {
|
|
90
|
+
delete usbIdentityProbes[commType];
|
|
91
|
+
});
|
|
92
|
+
usbIdentityProbes[commType] = probe;
|
|
93
|
+
return probe;
|
|
94
|
+
};
|
|
95
|
+
|
|
60
96
|
let _messageID = 0;
|
|
61
97
|
export const messagePromises: { [key: number]: Deferred<any> } = {};
|
|
62
98
|
|
|
63
99
|
const dispose = async () => {
|
|
64
100
|
const core = _core;
|
|
65
101
|
_core = undefined;
|
|
102
|
+
_plugin = undefined;
|
|
66
103
|
eventEmitter.removeAllListeners();
|
|
67
104
|
Object.keys(messagePromises).forEach(key => {
|
|
68
105
|
delete messagePromises[Number(key)];
|
|
@@ -158,6 +195,7 @@ const init = async (
|
|
|
158
195
|
try {
|
|
159
196
|
const Transport = await getTransport(_settings.env);
|
|
160
197
|
_core = await initCore(_settings, Transport, plugin);
|
|
198
|
+
_plugin = plugin;
|
|
161
199
|
_core?.on(CORE_EVENT, handleMessage);
|
|
162
200
|
setLoggerPostMessage(handleMessage);
|
|
163
201
|
|
|
@@ -188,6 +226,9 @@ const call = async (params: any) => {
|
|
|
188
226
|
if (response.payload?.code === HardwareErrorCode.BlePermissionError) {
|
|
189
227
|
postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_PERMISSION), false);
|
|
190
228
|
}
|
|
229
|
+
if (response.payload?.code === HardwareErrorCode.BleLocationError) {
|
|
230
|
+
postMessage(createUiMessage(UI_REQUEST.LOCATION_PERMISSION), false);
|
|
231
|
+
}
|
|
191
232
|
}
|
|
192
233
|
|
|
193
234
|
return response;
|
|
@@ -203,6 +244,54 @@ const call = async (params: any) => {
|
|
|
203
244
|
const updateSettings = () => Promise.resolve(true);
|
|
204
245
|
const switchTransport = () => Promise.resolve({ success: true });
|
|
205
246
|
|
|
247
|
+
const addHardwareGlobalEventListener = (listener: (message: CoreMessage) => void) => {
|
|
248
|
+
[
|
|
249
|
+
UI_EVENT,
|
|
250
|
+
LOG_EVENT,
|
|
251
|
+
FIRMWARE_EVENT,
|
|
252
|
+
DEVICE.CONNECT,
|
|
253
|
+
DEVICE.DISCONNECT,
|
|
254
|
+
DEVICE.FEATURES,
|
|
255
|
+
DEVICE.STATE,
|
|
256
|
+
DEVICE.SUPPORT_FEATURES,
|
|
257
|
+
UI_REQUEST.FIRMWARE_PROGRESS,
|
|
258
|
+
UI_REQUEST.FIRMWARE_TIP,
|
|
259
|
+
UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
|
|
260
|
+
].forEach(eventName => {
|
|
261
|
+
eventEmitter.on(eventName, (message: CoreMessage) => {
|
|
262
|
+
// Match the Web SDK envelope for device events emitted as payloads.
|
|
263
|
+
const envelope: { event?: string; type?: string } = message;
|
|
264
|
+
let emitMessage = message;
|
|
265
|
+
if (!envelope.event && !envelope.type) {
|
|
266
|
+
emitMessage = { ...message };
|
|
267
|
+
Object.assign(emitMessage, { event: eventName, type: eventName });
|
|
268
|
+
}
|
|
269
|
+
listener(emitMessage);
|
|
270
|
+
});
|
|
271
|
+
});
|
|
272
|
+
};
|
|
273
|
+
|
|
274
|
+
export const HardwareSDKLowLevel = HardwareLowLevelSdk({
|
|
275
|
+
eventEmitter,
|
|
276
|
+
init: (settings, sdk, plugin) => init({ ..._settings, ...settings }, sdk, plugin),
|
|
277
|
+
call,
|
|
278
|
+
cancel,
|
|
279
|
+
dispose,
|
|
280
|
+
addHardwareGlobalEventListener,
|
|
281
|
+
uiResponse,
|
|
282
|
+
updateSettings: (settings: Partial<ConnectSettings>) => {
|
|
283
|
+
if (_core) throw ERRORS.TypedError(HardwareErrorCode.IFrameAleradyInitialized);
|
|
284
|
+
_settings = parseConnectSettings({ ..._settings, ...settings });
|
|
285
|
+
return Promise.resolve(true);
|
|
286
|
+
},
|
|
287
|
+
switchTransport: async (env: ConnectSettings['env']) => {
|
|
288
|
+
if (!_core) throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
|
|
289
|
+
const Transport = await getTransport(env);
|
|
290
|
+
switchCoreTransport({ env, Transport, plugin: _plugin });
|
|
291
|
+
return { success: true, payload: {} };
|
|
292
|
+
},
|
|
293
|
+
});
|
|
294
|
+
|
|
206
295
|
const HardwareCommonConnectSdk = HardwareSdk({
|
|
207
296
|
eventEmitter,
|
|
208
297
|
init,
|