@onekeyfe/hd-common-connect-sdk 1.2.0-alpha.57 → 1.2.0-alpha.59

package/README.md

@@ -1,7 +1,6 @@
 # `@onekeyfe/hd-common-connect-sdk`
 
-`@onekeyfe/hd-common-connect-sdk` selects the transport for Node, browser WebUSB,
-Electron BLE, low-level, and emulator environments. It does not use an iframe.
+`@onekeyfe/hd-common-connect-sdk` is a libarary that runs in the node enviroment. And communicates with transport in the normal way.
 
 ## Installation
 
@@ -25,18 +24,13 @@ import HardwareSDK from '@onekeyfe/hd-common-connect-sdk';
 function init() {
   HardwareSDK.init({
     debug: false,
-    env: 'webusb',
   });
 }
 ```
 
-Test and factory-only methods are intentionally absent from the default SDK. Use
-`@onekeyfe/hd-test-api` when those methods are required.
-
 ## Docs
 
 Documentation is available [hardware-js-sdk](https://developer.onekey.so/connect-to-hardware/hardware-sdk/start)
 
 ## Examples
-
 // TODO: add example url

package/__tests__/device-state-event.test.js

@@ -1,17 +1,15 @@
 import { CORE_EVENT, DEVICE, DEVICE_EVENT, initCore } from '@onekeyfe/hd-core';
-import { WebUsbTransport } from '@onekeyfe/hd-transport-web-device';
 
-import HardwareCommonConnectSdk, { createHardwareCommonConnectSdk } from '../src';
+import HardwareCommonConnectSdk from '../src';
 
 jest.mock('@onekeyfe/hd-core', () => {
   const actual = jest.requireActual('@onekeyfe/hd-core');
   return {
     __esModule: true,
     ...actual,
-    default: ({ eventEmitter, init, dispose, call }) => ({
+    default: ({ eventEmitter, init, dispose }) => ({
       init,
       dispose,
-      call,
       on: (type, listener) => eventEmitter.on(type, listener),
       off: (type, listener) => eventEmitter.off(type, listener),
       removeAllListeners: type => eventEmitter.removeAllListeners(type),
@@ -79,11 +77,6 @@ describe('hd-common-connect-sdk device state events', () => {
     HardwareCommonConnectSdk.on(DEVICE.STATE, listener);
 
     await HardwareCommonConnectSdk.init({ env: 'webusb' });
-    expect(initCore).toHaveBeenLastCalledWith(
-      expect.objectContaining({ env: 'webusb' }),
-      WebUsbTransport,
-      undefined
-    );
     const payload = {
       connectId: 'connect-id',
       revision: 1,
@@ -101,33 +94,4 @@ describe('hd-common-connect-sdk device state events', () => {
     HardwareCommonConnectSdk.removeAllListeners(DEVICE.STATE);
     await HardwareCommonConnectSdk.dispose();
   });
-
-  test('keeps method extensions scoped to the created SDK instance', async () => {
-    const methodExtension = {
-      name: 'test-extension',
-      methods: {},
-    };
-    const extendedSdk = createHardwareCommonConnectSdk({
-      extension: {
-        methodExtensions: [methodExtension],
-        createApi: () => ({ extensionMarker: () => 'enabled' }),
-      },
-    });
-
-    expect(extendedSdk.extensionMarker()).toBe('enabled');
-    expect(HardwareCommonConnectSdk).not.toHaveProperty('extensionMarker');
-
-    initCore.mockResolvedValue({ on: jest.fn(), dispose: jest.fn() });
-    await extendedSdk.init({ env: 'webusb' });
-    expect(initCore).toHaveBeenLastCalledWith(
-      expect.objectContaining({ env: 'webusb' }),
-      WebUsbTransport,
-      undefined,
-      {
-        methodExtensions: [methodExtension],
-        allowDestructiveOperations: false,
-      }
-    );
-    await extendedSdk.dispose();
-  });
 });

package/dist/index.d.ts

@@ -1,18 +1,9 @@
-import { CoreMethodExtension, CoreApi } from '@onekeyfe/hd-core';
+import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
 import { Deferred } from '@onekeyfe/hd-shared';
 
-type HardwareCommonConnectSdkExtension<TExtensionApi extends object> = {
-    methodExtensions: readonly CoreMethodExtension[];
-    createApi: (call: CoreApi['call']) => TExtensionApi;
-};
-type HardwareCommonConnectSdkOptions<TExtensionApi extends object> = {
-    extension?: HardwareCommonConnectSdkExtension<TExtensionApi>;
-    allowDestructiveOperations?: boolean;
-};
-declare const createHardwareCommonConnectSdk: <TExtensionApi extends object = Record<never, never>>(options?: HardwareCommonConnectSdkOptions<TExtensionApi>) => CoreApi & TExtensionApi;
-declare const HardwareCommonConnectSdk: CoreApi & object;
 declare const messagePromises: {
     [key: number]: Deferred<any>;
 };
+declare const HardwareCommonConnectSdk: _onekeyfe_hd_core.CoreApi;
 
-export { HardwareCommonConnectSdkExtension, HardwareCommonConnectSdkOptions, createHardwareCommonConnectSdk, HardwareCommonConnectSdk as default, messagePromises };
+export { HardwareCommonConnectSdk as default, messagePromises };

package/dist/index.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var HardwareSdk = require('@onekeyfe/hd-core');
 var hdShared = require('@onekeyfe/hd-shared');
-var EmulatorTransport = require('@onekeyfe/hd-transport-emulator');
 var HttpTransport = require('@onekeyfe/hd-transport-http');
-var LowlevelTransport = require('@onekeyfe/hd-transport-lowlevel');
 var hdTransportWebDevice = require('@onekeyfe/hd-transport-web-device');
+var LowlevelTransport = require('@onekeyfe/hd-transport-lowlevel');
+var EmulatorTransport = require('@onekeyfe/hd-transport-emulator');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -30,9 +30,9 @@ function _interopNamespace(e) {
 }
 
 var HardwareSdk__default = /*#__PURE__*/_interopDefaultLegacy(HardwareSdk);
-var EmulatorTransport__default = /*#__PURE__*/_interopDefaultLegacy(EmulatorTransport);
 var HttpTransport__default = /*#__PURE__*/_interopDefaultLegacy(HttpTransport);
 var LowlevelTransport__default = /*#__PURE__*/_interopDefaultLegacy(LowlevelTransport);
+var EmulatorTransport__default = /*#__PURE__*/_interopDefaultLegacy(EmulatorTransport);
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -579,6 +579,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
+var eventEmitter = new events.exports();
 var Log = HardwareSdk.getLogger(HardwareSdk.LoggerNames.HdCommonConnectSdk);
 var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, function () {
     var NodeUsbTransport;
@@ -604,225 +605,185 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
         }
     });
 }); };
-var createSdkInstance = function (options) {
-    var _a, _b;
-    if (options === void 0) { options = {}; }
-    var eventEmitter = new events.exports.EventEmitter();
+var _core;
+var _settings = HardwareSdk.parseConnectSettings();
+var _messageID = 0;
+var messagePromises = {};
+var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
     var core;
-    var settings = HardwareSdk.parseConnectSettings();
-    var messageID = 0;
-    var instanceMessagePromises = {};
-    var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var currentCore;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    currentCore = core;
-                    core = undefined;
-                    eventEmitter.removeAllListeners();
-                    Object.keys(instanceMessagePromises).forEach(function (key) {
-                        delete instanceMessagePromises[Number(key)];
-                    });
-                    settings = HardwareSdk.parseConnectSettings();
-                    return [4 /*yield*/, ((_a = currentCore === null || currentCore === void 0 ? void 0 : currentCore.dispose) === null || _a === void 0 ? void 0 : _a.call(currentCore))];
-                case 1:
-                    _b.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    var uiResponse = function (response) {
-        if (!core) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
-        }
-        var type = response.type, payload = response.payload;
-        core
-            .handleMessage({ event: HardwareSdk.UI_EVENT, type: type, payload: payload })
-            .catch(function (error) { return Log.error(HardwareSdk.createErrorMessage(error)); });
-    };
-    var cancel = function (connectId) {
-        if (!core)
-            return;
-        core
-            .handleMessage({
-            event: HardwareSdk.IFRAME.CANCEL,
-            type: HardwareSdk.IFRAME.CANCEL,
-            payload: { connectId: connectId },
-        })
-            .catch(function (error) { return Log.error(HardwareSdk.createErrorMessage(error)); });
-    };
-    function handleMessage(message) {
-        var event = message.event;
-        if (!core) {
-            return;
-        }
-        var blockLog = HardwareSdk.getLogBlockLabel(message);
-        if (event !== HardwareSdk.LOG_EVENT) {
-            Log.debug('hd-common-connect-sdk handleMessage', blockLog !== null && blockLog !== void 0 ? blockLog : message);
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                core = _core;
+                _core = undefined;
+                eventEmitter.removeAllListeners();
+                Object.keys(messagePromises).forEach(function (key) {
+                    delete messagePromises[Number(key)];
+                });
+                _settings = HardwareSdk.parseConnectSettings();
+                return [4 /*yield*/, ((_a = core === null || core === void 0 ? void 0 : core.dispose) === null || _a === void 0 ? void 0 : _a.call(core))];
+            case 1:
+                _b.sent();
+                return [2 /*return*/];
         }
-        switch (event) {
-            case HardwareSdk.UI_EVENT:
-                eventEmitter.emit(message.event, message);
+    });
+}); };
+var uiResponse = function (response) {
+    if (!_core) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
+    }
+    var type = response.type, payload = response.payload;
+    _core.handleMessage({ event: HardwareSdk.UI_EVENT, type: type, payload: payload });
+};
+var cancel = function (connectId) {
+    if (_core === undefined)
+        return;
+    _core.handleMessage({ event: HardwareSdk.IFRAME.CANCEL, type: HardwareSdk.IFRAME.CANCEL, payload: { connectId: connectId } });
+};
+function handleMessage(message) {
+    var event = message.event;
+    if (!_core) {
+        return;
+    }
+    var blockLog = HardwareSdk.getLogBlockLabel(message);
+    if (event !== HardwareSdk.LOG_EVENT) {
+        Log.debug('hd-common-connect-sdk handleMessage', blockLog !== null && blockLog !== void 0 ? blockLog : message);
+    }
+    switch (event) {
+        case HardwareSdk.UI_EVENT:
+            // pass UI event up
+            eventEmitter.emit(message.event, message);
+            eventEmitter.emit(message.type, message.payload);
+            break;
+        case HardwareSdk.LOG_EVENT:
+        case HardwareSdk.FIRMWARE_EVENT:
+            eventEmitter.emit(message.event, message);
+            break;
+        case HardwareSdk.DEVICE_EVENT:
+            if ([
+                HardwareSdk.DEVICE.CONNECT,
+                HardwareSdk.DEVICE.DISCONNECT,
+                HardwareSdk.DEVICE.FEATURES,
+                HardwareSdk.DEVICE.STATE,
+                HardwareSdk.DEVICE.SUPPORT_FEATURES,
+            ].includes(message.type)) {
                 eventEmitter.emit(message.type, message.payload);
-                break;
-            case HardwareSdk.LOG_EVENT:
-            case HardwareSdk.FIRMWARE_EVENT:
-                eventEmitter.emit(message.event, message);
-                break;
-            case HardwareSdk.DEVICE_EVENT:
-                if ([
-                    HardwareSdk.DEVICE.CONNECT,
-                    HardwareSdk.DEVICE.DISCONNECT,
-                    HardwareSdk.DEVICE.FEATURES,
-                    HardwareSdk.DEVICE.STATE,
-                    HardwareSdk.DEVICE.SUPPORT_FEATURES,
-                ].includes(message.type)) {
-                    eventEmitter.emit(message.type, message.payload);
-                }
-                break;
-            case HardwareSdk.IFRAME.CALLBACK: {
-                var _a = message.payload, callbackId = _a.callbackId, data = _a.data, error = _a.error;
-                HardwareSdk.executeCallback(callbackId, data, error);
-                break;
             }
-            default:
-                Log.log('No need to be captured message', message.event);
+            break;
+        case HardwareSdk.IFRAME.CALLBACK: {
+            var _a = message.payload, callbackId = _a.callbackId, data = _a.data, error = _a.error;
+            HardwareSdk.executeCallback(callbackId, data, error);
+            break;
         }
+        default:
+            Log.log('No need to be captured message', message.event);
     }
-    function postMessage(message, usePromise) {
-        if (usePromise === void 0) { usePromise = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!core) {
-                            throw hdShared.ERRORS.TypedError('postMessage: _core not found');
-                        }
-                        if (usePromise) {
-                            messageID += 1;
-                            instanceMessagePromises[messageID] = hdShared.createDeferred();
-                            return [2 /*return*/, core.handleMessage(__assign(__assign({}, message), { id: "".concat(messageID) }))];
-                        }
-                        return [4 /*yield*/, core.handleMessage(message)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    }
-    var init = function (partialSettings, _, plugin) { return __awaiter(void 0, void 0, void 0, function () {
-        var Transport, error_1;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+}
+function postMessage(message, usePromise) {
+    if (usePromise === void 0) { usePromise = true; }
+    return __awaiter(this, void 0, void 0, function () {
+        var response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
-                    settings = __assign(__assign(__assign({}, settings), partialSettings), { env: (_a = partialSettings.env) !== null && _a !== void 0 ? _a : 'node' });
-                    HardwareSdk.enableLog(!!partialSettings.debug);
-                    Log.debug('init');
-                    _b.label = 1;
+                    if (!_core) {
+                        throw hdShared.ERRORS.TypedError('postMessage: _core not found');
+                    }
+                    if (!usePromise) return [3 /*break*/, 2];
+                    _messageID++;
+                    messagePromises[_messageID] = hdShared.createDeferred();
+                    return [4 /*yield*/, _core.handleMessage(__assign(__assign({}, message), { id: "".concat(_messageID) }))];
                 case 1:
-                    _b.trys.push([1, 7, , 8]);
-                    return [4 /*yield*/, getTransport(settings.env)];
+                    response = _a.sent();
+                    // return promise;
+                    return [2 /*return*/, response];
                 case 2:
-                    Transport = _b.sent();
-                    if (!options.extension) return [3 /*break*/, 4];
-                    return [4 /*yield*/, HardwareSdk.initCore(settings, Transport, plugin, {
-                            methodExtensions: options.extension.methodExtensions,
-                            allowDestructiveOperations: options.allowDestructiveOperations === true,
-                        })];
-                case 3:
-                    core = _b.sent();
-                    return [3 /*break*/, 6];
-                case 4: return [4 /*yield*/, HardwareSdk.initCore(settings, Transport, plugin)];
-                case 5:
-                    core = _b.sent();
-                    _b.label = 6;
-                case 6:
-                    core === null || core === void 0 ? void 0 : core.on(HardwareSdk.CORE_EVENT, handleMessage);
-                    HardwareSdk.setLoggerPostMessage(handleMessage);
-                    return [2 /*return*/, true];
-                case 7:
-                    error_1 = _b.sent();
-                    Log.error(HardwareSdk.createErrorMessage(error_1));
-                    return [2 /*return*/, false];
-                case 8: return [2 /*return*/];
+                    _core.handleMessage(message);
+                    return [2 /*return*/];
             }
         });
-    }); };
-    var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var blockLog, response, error_2;
-        var _a, _b, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    blockLog = HardwareSdk.getLogBlockLabel(params);
-                    Log.debug('call: ', blockLog !== null && blockLog !== void 0 ? blockLog : params);
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, postMessage({
-                            event: HardwareSdk.IFRAME.CALL,
-                            type: HardwareSdk.IFRAME.CALL,
-                            payload: params,
-                        })];
-                case 2:
-                    response = _d.sent();
-                    if (response) {
-                        Log.debug('response: ', blockLog ? '[REDACTED]' : response);
-                        if (!response.success) {
-                            if (((_a = response.payload) === null || _a === void 0 ? void 0 : _a.code) === hdShared.HardwareErrorCode.BleUnsupported) {
-                                postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_UNSUPPORTED), false).catch(function (error) {
-                                    return Log.error(HardwareSdk.createErrorMessage(error));
-                                });
-                            }
-                            if (((_b = response.payload) === null || _b === void 0 ? void 0 : _b.code) === hdShared.HardwareErrorCode.BlePoweredOff) {
-                                postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_POWERED_OFF), false).catch(function (error) {
-                                    return Log.error(HardwareSdk.createErrorMessage(error));
-                                });
-                            }
-                            if (((_c = response.payload) === null || _c === void 0 ? void 0 : _c.code) === hdShared.HardwareErrorCode.BlePermissionError) {
-                                postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_PERMISSION), false).catch(function (error) {
-                                    return Log.error(HardwareSdk.createErrorMessage(error));
-                                });
-                            }
+    });
+}
+var init = function (settings, _, plugin) { return __awaiter(void 0, void 0, void 0, function () {
+    var Transport, error_1;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _settings = __assign(__assign(__assign({}, _settings), settings), { env: (_a = settings.env) !== null && _a !== void 0 ? _a : 'node' });
+                HardwareSdk.enableLog(!!settings.debug);
+                Log.debug('init');
+                _b.label = 1;
+            case 1:
+                _b.trys.push([1, 4, , 5]);
+                return [4 /*yield*/, getTransport(_settings.env)];
+            case 2:
+                Transport = _b.sent();
+                return [4 /*yield*/, HardwareSdk.initCore(_settings, Transport, plugin)];
+            case 3:
+                _core = _b.sent();
+                _core === null || _core === void 0 ? void 0 : _core.on(HardwareSdk.CORE_EVENT, handleMessage);
+                HardwareSdk.setLoggerPostMessage(handleMessage);
+                return [2 /*return*/, true];
+            case 4:
+                error_1 = _b.sent();
+                Log.error(HardwareSdk.createErrorMessage(error_1));
+                return [2 /*return*/, false];
+            case 5: return [2 /*return*/];
+        }
+    });
+}); };
+var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
+    var blockLog, response, error_2;
+    var _a, _b, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                blockLog = HardwareSdk.getLogBlockLabel(params);
+                Log.debug('call: ', blockLog !== null && blockLog !== void 0 ? blockLog : params);
+                _d.label = 1;
+            case 1:
+                _d.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, postMessage({ event: HardwareSdk.IFRAME.CALL, type: HardwareSdk.IFRAME.CALL, payload: params })];
+            case 2:
+                response = _d.sent();
+                if (response) {
+                    Log.debug('response: ', blockLog ? '[REDACTED]' : response);
+                    if (!response.success) {
+                        if (((_a = response.payload) === null || _a === void 0 ? void 0 : _a.code) === hdShared.HardwareErrorCode.BleUnsupported) {
+                            postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_UNSUPPORTED), false);
+                        }
+                        if (((_b = response.payload) === null || _b === void 0 ? void 0 : _b.code) === hdShared.HardwareErrorCode.BlePoweredOff) {
+                            postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_POWERED_OFF), false);
+                        }
+                        if (((_c = response.payload) === null || _c === void 0 ? void 0 : _c.code) === hdShared.HardwareErrorCode.BlePermissionError) {
+                            postMessage(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_PERMISSION), false);
                         }
-                        return [2 /*return*/, response];
                     }
-                    return [2 /*return*/, HardwareSdk.createErrorMessage(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodNotResponse))];
-                case 3:
-                    error_2 = _d.sent();
-                    Log.error('__call error: ', error_2);
-                    return [2 /*return*/, HardwareSdk.createErrorMessage(error_2)];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); };
-    var updateSettings = function () { return Promise.resolve(true); };
-    var switchTransport = function () { return Promise.resolve({ success: true }); };
-    var sdk = HardwareSdk__default["default"]({
-        eventEmitter: eventEmitter,
-        init: init,
-        call: call,
-        cancel: cancel,
-        dispose: dispose,
-        uiResponse: uiResponse,
-        updateSettings: updateSettings,
-        switchTransport: switchTransport,
+                    return [2 /*return*/, response];
+                }
+                return [2 /*return*/, HardwareSdk.createErrorMessage(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodNotResponse))];
+            case 3:
+                error_2 = _d.sent();
+                Log.error('__call error: ', error_2);
+                return [2 /*return*/, HardwareSdk.createErrorMessage(error_2)];
+            case 4: return [2 /*return*/];
+        }
     });
-    var extensionApi = (_b = (_a = options.extension) === null || _a === void 0 ? void 0 : _a.createApi(sdk.call)) !== null && _b !== void 0 ? _b : {};
-    return {
-        sdk: Object.assign(sdk, extensionApi),
-        messagePromises: instanceMessagePromises,
-    };
-};
-var createHardwareCommonConnectSdk = function (options) {
-    if (options === void 0) { options = {}; }
-    return createSdkInstance(options).sdk;
-};
-var _a = createSdkInstance(), HardwareCommonConnectSdk = _a.sdk, messagePromises = _a.messagePromises;
+}); };
+var updateSettings = function () { return Promise.resolve(true); };
+var switchTransport = function () { return Promise.resolve({ success: true }); };
+var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
+    eventEmitter: eventEmitter,
+    init: init,
+    call: call,
+    cancel: cancel,
+    dispose: dispose,
+    uiResponse: uiResponse,
+    updateSettings: updateSettings,
+    switchTransport: switchTransport,
+});
 
-exports.createHardwareCommonConnectSdk = createHardwareCommonConnectSdk;
 exports["default"] = HardwareCommonConnectSdk;
 exports.messagePromises = messagePromises;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-common-connect-sdk",
-  "version": "1.2.0-alpha.57",
+  "version": "1.2.0-alpha.59",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "ISC",
@@ -20,13 +20,13 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.0-alpha.57",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.57",
-    "@onekeyfe/hd-transport-emulator": "1.2.0-alpha.57",
-    "@onekeyfe/hd-transport-http": "1.2.0-alpha.57",
-    "@onekeyfe/hd-transport-lowlevel": "1.2.0-alpha.57",
-    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.57",
-    "@onekeyfe/hd-transport-web-device": "1.2.0-alpha.57"
+    "@onekeyfe/hd-core": "1.2.0-alpha.59",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.59",
+    "@onekeyfe/hd-transport-emulator": "1.2.0-alpha.59",
+    "@onekeyfe/hd-transport-http": "1.2.0-alpha.59",
+    "@onekeyfe/hd-transport-lowlevel": "1.2.0-alpha.59",
+    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.59",
+    "@onekeyfe/hd-transport-web-device": "1.2.0-alpha.59"
   },
-  "gitHead": "3279714eb381518b8dec4837d388271e74a0a5e6"
+  "gitHead": "98794c3032aab55e13fb2afedc645d8281141d5f"
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events';
+import EventEmitter from 'events';
 import HardwareSdk, {
   CORE_EVENT,
   DEVICE,
@@ -20,23 +20,22 @@ import HardwareSdk, {
   setLoggerPostMessage,
 } from '@onekeyfe/hd-core';
 import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
-import EmulatorTransport from '@onekeyfe/hd-transport-emulator';
 import HttpTransport from '@onekeyfe/hd-transport-http';
-import LowlevelTransport from '@onekeyfe/hd-transport-lowlevel';
 import { ElectronBleTransport, WebUsbTransport } from '@onekeyfe/hd-transport-web-device';
+import LowlevelTransport from '@onekeyfe/hd-transport-lowlevel';
+import EmulatorTransport from '@onekeyfe/hd-transport-emulator';
 
+import type { Deferred } from '@onekeyfe/hd-shared';
 import type {
   ConnectSettings,
   Core,
-  CoreApi,
   CoreMessage,
-  CoreMethodExtension,
   LowLevelCoreApi,
   UiResponseEvent,
 } from '@onekeyfe/hd-core';
-import type { Deferred } from '@onekeyfe/hd-shared';
 import type { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
 
+const eventEmitter = new EventEmitter();
 const Log = getLogger(LoggerNames.HdCommonConnectSdk);
 
 const getTransport = async (env: ConnectSettings['env']) => {
@@ -46,7 +45,8 @@ const getTransport = async (env: ConnectSettings['env']) => {
   if (env === 'webusb' || env === 'desktop-webusb') return WebUsbTransport;
   if (env === 'lowlevel') return LowlevelTransport;
   if (env === 'node-usb') {
-    // Keep the native libusb binding out of browser and React Native bundles.
+    // Dynamic import — usb is a native Node.js module (libusb C++ bindings)
+    // that cannot be resolved by browser/React Native bundlers
     const { default: NodeUsbTransport } = await import('@onekeyfe/hd-transport-usb');
     return NodeUsbTransport;
   }
@@ -54,218 +54,166 @@ const getTransport = async (env: ConnectSettings['env']) => {
   return HttpTransport;
 };
 
-export type HardwareCommonConnectSdkExtension<TExtensionApi extends object> = {
-  methodExtensions: readonly CoreMethodExtension[];
-  createApi: (call: CoreApi['call']) => TExtensionApi;
-};
+let _core: Core | undefined;
+let _settings = parseConnectSettings();
 
-export type HardwareCommonConnectSdkOptions<TExtensionApi extends object> = {
-  extension?: HardwareCommonConnectSdkExtension<TExtensionApi>;
-  allowDestructiveOperations?: boolean;
-};
+let _messageID = 0;
+export const messagePromises: { [key: number]: Deferred<any> } = {};
 
-type SdkInstance<TExtensionApi extends object> = {
-  sdk: CoreApi & TExtensionApi;
-  messagePromises: { [key: number]: Deferred<any> };
+const dispose = async () => {
+  const core = _core;
+  _core = undefined;
+  eventEmitter.removeAllListeners();
+  Object.keys(messagePromises).forEach(key => {
+    delete messagePromises[Number(key)];
+  });
+  _settings = parseConnectSettings();
+  await core?.dispose?.();
 };
 
-const createSdkInstance = <TExtensionApi extends object>(
-  options: HardwareCommonConnectSdkOptions<TExtensionApi> = {}
-): SdkInstance<TExtensionApi> => {
-  const eventEmitter = new EventEmitter();
-  let core: Core | undefined;
-  let settings = parseConnectSettings();
-  let messageID = 0;
-  const instanceMessagePromises: { [key: number]: Deferred<any> } = {};
-
-  const dispose = async () => {
-    const currentCore = core;
-    core = undefined;
-    eventEmitter.removeAllListeners();
-    Object.keys(instanceMessagePromises).forEach(key => {
-      delete instanceMessagePromises[Number(key)];
-    });
-    settings = parseConnectSettings();
-    await currentCore?.dispose?.();
-  };
-
-  const uiResponse = (response: UiResponseEvent) => {
-    if (!core) {
-      throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
-    }
-    const { type, payload } = response;
-    core
-      .handleMessage({ event: UI_EVENT, type, payload } as CoreMessage)
-      .catch(error => Log.error(createErrorMessage(error)));
-  };
+const uiResponse = (response: UiResponseEvent) => {
+  if (!_core) {
+    throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
+  }
+  const { type, payload } = response;
+  _core.handleMessage({ event: UI_EVENT, type, payload } as CoreMessage);
+};
 
-  const cancel = (connectId?: string) => {
-    if (!core) return;
-    core
-      .handleMessage({
-        event: IFRAME.CANCEL,
-        type: IFRAME.CANCEL,
-        payload: { connectId },
-      })
-      .catch(error => Log.error(createErrorMessage(error)));
-  };
+const cancel = (connectId?: string) => {
+  if (_core === undefined) return;
+  _core.handleMessage({ event: IFRAME.CANCEL, type: IFRAME.CANCEL, payload: { connectId } });
+};
 
-  function handleMessage(message: CoreMessage) {
-    const { event } = message;
-    if (!core) {
-      return;
-    }
+function handleMessage(message: CoreMessage) {
+  const { event } = message;
+  if (!_core) {
+    return;
+  }
 
-    const blockLog = getLogBlockLabel(message);
-    if (event !== LOG_EVENT) {
-      Log.debug('hd-common-connect-sdk handleMessage', blockLog ?? message);
-    }
-    switch (event) {
-      case UI_EVENT:
-        eventEmitter.emit(message.event, message);
+  const blockLog = getLogBlockLabel(message);
+  if (event !== LOG_EVENT) {
+    Log.debug('hd-common-connect-sdk handleMessage', blockLog ?? message);
+  }
+  switch (event) {
+    case UI_EVENT:
+      // pass UI event up
+      eventEmitter.emit(message.event, message);
+      eventEmitter.emit(message.type, message.payload);
+      break;
+    case LOG_EVENT:
+    case FIRMWARE_EVENT:
+      eventEmitter.emit(message.event, message);
+      break;
+    case DEVICE_EVENT:
+      if (
+        (
+          [
+            DEVICE.CONNECT,
+            DEVICE.DISCONNECT,
+            DEVICE.FEATURES,
+            DEVICE.STATE,
+            DEVICE.SUPPORT_FEATURES,
+          ] as string[]
+        ).includes(message.type)
+      ) {
         eventEmitter.emit(message.type, message.payload);
-        break;
-      case LOG_EVENT:
-      case FIRMWARE_EVENT:
-        eventEmitter.emit(message.event, message);
-        break;
-      case DEVICE_EVENT:
-        if (
-          (
-            [
-              DEVICE.CONNECT,
-              DEVICE.DISCONNECT,
-              DEVICE.FEATURES,
-              DEVICE.STATE,
-              DEVICE.SUPPORT_FEATURES,
-            ] as string[]
-          ).includes(message.type)
-        ) {
-          eventEmitter.emit(message.type, message.payload);
-        }
-        break;
-      case IFRAME.CALLBACK: {
-        const { callbackId, data, error } = message.payload;
-        executeCallback(callbackId, data, error);
-        break;
       }
-      default:
-        Log.log('No need to be captured message', message.event);
+      break;
+    case IFRAME.CALLBACK: {
+      const { callbackId, data, error } = message.payload;
+      executeCallback(callbackId, data, error);
+      break;
     }
+    default:
+      Log.log('No need to be captured message', message.event);
   }
+}
 
-  async function postMessage(message: CoreMessage, usePromise = true) {
-    if (!core) {
-      throw ERRORS.TypedError('postMessage: _core not found');
-    }
-
-    if (usePromise) {
-      messageID += 1;
-      instanceMessagePromises[messageID] = createDeferred();
-      return core.handleMessage({ ...message, id: `${messageID}` });
-    }
+async function postMessage(message: CoreMessage, usePromise = true) {
+  if (!_core) {
+    throw ERRORS.TypedError('postMessage: _core not found');
+  }
 
-    await core.handleMessage(message);
+  if (usePromise) {
+    _messageID++;
+    messagePromises[_messageID] = createDeferred();
+    // const { promise } = messagePromises[_messageID];
+    const response = await _core.handleMessage({ ...message, id: `${_messageID}` });
+    // return promise;
+    return response;
   }
 
-  const init = async (
-    partialSettings: Partial<ConnectSettings>,
-    _?: LowLevelCoreApi,
-    plugin?: LowlevelTransportSharedPlugin
-  ) => {
-    settings = { ...settings, ...partialSettings, env: partialSettings.env ?? 'node' };
+  _core.handleMessage(message);
+}
 
-    enableLog(!!partialSettings.debug);
-    Log.debug('init');
+const init = async (
+  settings: Partial<ConnectSettings>,
+  _?: LowLevelCoreApi,
+  plugin?: LowlevelTransportSharedPlugin
+) => {
+  _settings = { ..._settings, ...settings, env: settings.env ?? 'node' };
 
-    try {
-      const Transport = await getTransport(settings.env);
-      if (options.extension) {
-        core = await initCore(settings, Transport, plugin, {
-          methodExtensions: options.extension.methodExtensions,
-          allowDestructiveOperations: options.allowDestructiveOperations === true,
-        });
-      } else {
-        core = await initCore(settings, Transport, plugin);
-      }
-      core?.on(CORE_EVENT, handleMessage);
-      setLoggerPostMessage(handleMessage);
+  enableLog(!!settings.debug);
 
-      return true;
-    } catch (error) {
-      Log.error(createErrorMessage(error));
-      return false;
-    }
-  };
+  Log.debug('init');
 
-  const call: CoreApi['call'] = async params => {
-    const blockLog = getLogBlockLabel(params);
-    Log.debug('call: ', blockLog ?? params);
+  try {
+    const Transport = await getTransport(_settings.env);
+    _core = await initCore(_settings, Transport, plugin);
+    _core?.on(CORE_EVENT, handleMessage);
+    setLoggerPostMessage(handleMessage);
 
-    try {
-      const response = await postMessage({
-        event: IFRAME.CALL,
-        type: IFRAME.CALL,
-        payload: params,
-      });
-      if (response) {
-        Log.debug('response: ', blockLog ? '[REDACTED]' : response);
+    return true;
+  } catch (error) {
+    Log.error(createErrorMessage(error));
 
-        if (!response.success) {
-          if (response.payload?.code === HardwareErrorCode.BleUnsupported) {
-            postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_UNSUPPORTED), false).catch(error =>
-              Log.error(createErrorMessage(error))
-            );
-          }
-          if (response.payload?.code === HardwareErrorCode.BlePoweredOff) {
-            postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_POWERED_OFF), false).catch(error =>
-              Log.error(createErrorMessage(error))
-            );
-          }
-          if (response.payload?.code === HardwareErrorCode.BlePermissionError) {
-            postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_PERMISSION), false).catch(error =>
-              Log.error(createErrorMessage(error))
-            );
-          }
-        }
+    return false;
+  }
+};
 
-        return response;
-      }
+const call = async (params: any) => {
+  const blockLog = getLogBlockLabel(params);
+  Log.debug('call: ', blockLog ?? params);
 
-      return createErrorMessage(ERRORS.TypedError(HardwareErrorCode.CallMethodNotResponse));
-    } catch (error) {
-      Log.error('__call error: ', error);
-      return createErrorMessage(error);
-    }
-  };
+  try {
+    const response = await postMessage({ event: IFRAME.CALL, type: IFRAME.CALL, payload: params });
+    if (response) {
+      Log.debug('response: ', blockLog ? '[REDACTED]' : response);
 
-  const updateSettings = () => Promise.resolve(true);
-  const switchTransport = () => Promise.resolve({ success: true });
+      if (!response.success) {
+        if (response.payload?.code === HardwareErrorCode.BleUnsupported) {
+          postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_UNSUPPORTED), false);
+        }
+        if (response.payload?.code === HardwareErrorCode.BlePoweredOff) {
+          postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_POWERED_OFF), false);
+        }
+        if (response.payload?.code === HardwareErrorCode.BlePermissionError) {
+          postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_PERMISSION), false);
+        }
+      }
 
-  const sdk = HardwareSdk({
-    eventEmitter,
-    init,
-    call,
-    cancel,
-    dispose,
-    uiResponse,
-    updateSettings,
-    switchTransport,
-  });
-  const extensionApi = options.extension?.createApi(sdk.call) ?? ({} as TExtensionApi);
+      return response;
+    }
 
-  return {
-    sdk: Object.assign(sdk, extensionApi),
-    messagePromises: instanceMessagePromises,
-  };
+    return createErrorMessage(ERRORS.TypedError(HardwareErrorCode.CallMethodNotResponse));
+  } catch (error) {
+    Log.error('__call error: ', error);
+    return createErrorMessage(error);
+  }
 };
 
-export const createHardwareCommonConnectSdk = <TExtensionApi extends object = Record<never, never>>(
-  options: HardwareCommonConnectSdkOptions<TExtensionApi> = {}
-): CoreApi & TExtensionApi => createSdkInstance(options).sdk;
-
-const { sdk: HardwareCommonConnectSdk, messagePromises } = createSdkInstance();
-
-export { messagePromises };
+const updateSettings = () => Promise.resolve(true);
+const switchTransport = () => Promise.resolve({ success: true });
+
+const HardwareCommonConnectSdk = HardwareSdk({
+  eventEmitter,
+  init,
+  call,
+  cancel,
+  dispose,
+  uiResponse,
+  updateSettings,
+  switchTransport,
+});
 
 export default HardwareCommonConnectSdk;