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

package/README.md

@@ -1,6 +1,7 @@
 # `@onekeyfe/hd-common-connect-sdk`
 
-`@onekeyfe/hd-common-connect-sdk` is a libarary that runs in the node enviroment. And communicates with transport in the normal way.
+`@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.
 
 ## Installation
 
@@ -24,13 +25,18 @@ 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,15 +1,17 @@
 import { CORE_EVENT, DEVICE, DEVICE_EVENT, initCore } from '@onekeyfe/hd-core';
+import { WebUsbTransport } from '@onekeyfe/hd-transport-web-device';
 
-import HardwareCommonConnectSdk from '../src';
+import HardwareCommonConnectSdk, { createHardwareCommonConnectSdk } from '../src';
 
 jest.mock('@onekeyfe/hd-core', () => {
   const actual = jest.requireActual('@onekeyfe/hd-core');
   return {
     __esModule: true,
     ...actual,
-    default: ({ eventEmitter, init, dispose }) => ({
+    default: ({ eventEmitter, init, dispose, call }) => ({
       init,
       dispose,
+      call,
       on: (type, listener) => eventEmitter.on(type, listener),
       off: (type, listener) => eventEmitter.off(type, listener),
       removeAllListeners: type => eventEmitter.removeAllListeners(type),
@@ -77,6 +79,11 @@ 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,
@@ -94,4 +101,33 @@ 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,9 +1,18 @@
-import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
+import { CoreMethodExtension, CoreApi } 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 { HardwareCommonConnectSdk as default, messagePromises };
+export { HardwareCommonConnectSdkExtension, HardwareCommonConnectSdkOptions, createHardwareCommonConnectSdk, 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 hdTransportWebDevice = require('@onekeyfe/hd-transport-web-device');
 var LowlevelTransport = require('@onekeyfe/hd-transport-lowlevel');
-var EmulatorTransport = require('@onekeyfe/hd-transport-emulator');
+var hdTransportWebDevice = require('@onekeyfe/hd-transport-web-device');
 
 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,7 +579,6 @@ 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;
@@ -605,185 +604,225 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
         }
     });
 }); };
-var _core;
-var _settings = HardwareSdk.parseConnectSettings();
-var _messageID = 0;
-var messagePromises = {};
-var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
+var createSdkInstance = function (options) {
+    var _a, _b;
+    if (options === void 0) { options = {}; }
+    var eventEmitter = new events.exports.EventEmitter();
     var core;
-    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*/];
+    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 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)) {
+        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);
+        }
+        switch (event) {
+            case HardwareSdk.UI_EVENT:
+                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.IFRAME.CALLBACK: {
+                var _a = message.payload, callbackId = _a.callbackId, data = _a.data, error = _a.error;
+                HardwareSdk.executeCallback(callbackId, data, error);
+                break;
             }
-            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);
         }
-        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 () {
-        var response;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+    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) {
                 case 0:
-                    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) }))];
+                    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;
                 case 1:
-                    response = _a.sent();
-                    // return promise;
-                    return [2 /*return*/, response];
+                    _b.trys.push([1, 7, , 8]);
+                    return [4 /*yield*/, getTransport(settings.env)];
                 case 2:
-                    _core.handleMessage(message);
-                    return [2 /*return*/];
+                    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*/];
             }
         });
-    });
-}
-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);
+    }); };
+    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));
+                                });
+                            }
                         }
+                        return [2 /*return*/, response];
                     }
-                    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*/];
-        }
+                    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,
     });
-}); };
-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,
-});
+    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;
 
+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.55",
+  "version": "1.2.0-alpha.57",
   "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.55",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.55",
-    "@onekeyfe/hd-transport-emulator": "1.2.0-alpha.55",
-    "@onekeyfe/hd-transport-http": "1.2.0-alpha.55",
-    "@onekeyfe/hd-transport-lowlevel": "1.2.0-alpha.55",
-    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.55",
-    "@onekeyfe/hd-transport-web-device": "1.2.0-alpha.55"
+    "@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"
   },
-  "gitHead": "0a99a180062ec32fac0c5e14be3366fbfb7bc01a"
+  "gitHead": "3279714eb381518b8dec4837d388271e74a0a5e6"
 }

package/src/index.ts

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