@onekeyfe/hd-web-sdk 0.1.25 → 0.1.28

package/build/onekey-js-sdk.js

@@ -4133,6 +4133,10 @@ const inject = ({
       connectId,
       method: 'deviceUpdateReboot'
     }),
+    deviceSupportFeatures: connectId => call({
+      connectId,
+      method: 'deviceSupportFeatures'
+    }),
     deviceVerify: (connectId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
       method: 'deviceVerify'
@@ -4259,7 +4263,10 @@ const inject = ({
     firmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
       method: 'firmwareUpdate'
-    }))
+    })),
+    requestWebUsbDevice: () => call({
+      method: 'requestWebUsbDevice'
+    })
   };
   return api;
 };
@@ -13670,9 +13677,25 @@ const getDeviceBLEFirmwareVersion = features => {
     return null;
   }
 
+  if (!semver__default["default"].valid(features.ble_ver)) {
+    return null;
+  }
+
   return features.ble_ver.split('.');
 };
 
+const supportInputPinOnSoftware = features => {
+  if (!features) return false;
+  const deviceType = getDeviceType(features);
+
+  if (deviceType === 'touch') {
+    return false;
+  }
+
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+  return semver__default["default"].gte(currentVersion, '2.3.0');
+};
+
 const HD_HARDENED = 0x80000000;
 
 const toHardened = n => (n | HD_HARDENED) >>> 0;
@@ -13807,7 +13830,7 @@ const createLogMessage = (type, payload) => ({
 const MAX_ENTRIES = 500;
 let postMessage$1;
 
-class Log$6 {
+class Log$7 {
   constructor(prefix, enabled) {
     this.prefix = prefix;
     this.enabled = enabled;
@@ -13876,7 +13899,7 @@ class Log$6 {
 const _logs = {};
 
 const initLog = (prefix, enabled) => {
-  const instance = new Log$6(prefix, !!enabled);
+  const instance = new Log$7(prefix, !!enabled);
   _logs[prefix] = instance;
   return instance;
 };
@@ -13952,6 +13975,8 @@ exports.d0 = void 0;
   LoggerNames["DeviceCommands"] = "DeviceCommands";
   LoggerNames["DeviceConnector"] = "DeviceConnector";
   LoggerNames["DeviceList"] = "DeviceList";
+  LoggerNames["DevicePool"] = "DevicePool";
+  LoggerNames["HdCommonConnectSdk"] = "@onekey/common-connect-sdk";
   LoggerNames["HdBleSdk"] = "@onekey/hd-ble-sdk";
   LoggerNames["HdTransportHttp"] = "@onekey/hd-transport-http";
   LoggerNames["HdBleTransport"] = "@onekey/hd-ble-transport";
@@ -13968,13 +13993,15 @@ const LoggerMap = {
   [exports.d0.DeviceCommands]: initLog(exports.d0.DeviceCommands),
   [exports.d0.DeviceConnector]: initLog(exports.d0.DeviceConnector),
   [exports.d0.DeviceList]: initLog(exports.d0.DeviceList),
+  [exports.d0.DevicePool]: initLog(exports.d0.DevicePool),
   [exports.d0.HdBleSdk]: initLog(exports.d0.HdBleSdk),
   [exports.d0.HdTransportHttp]: initLog(exports.d0.HdTransportHttp),
   [exports.d0.HdBleTransport]: initLog(exports.d0.HdBleTransport),
   [exports.d0.Connect]: initLog(exports.d0.Connect),
   [exports.d0.Iframe]: initLog(exports.d0.Iframe),
   [exports.d0.SendMessage]: initLog(exports.d0.SendMessage),
-  [exports.d0.Method]: initLog(exports.d0.Method)
+  [exports.d0.Method]: initLog(exports.d0.Method),
+  [exports.d0.HdCommonConnectSdk]: initLog(exports.d0.Method)
 };
 
 const getLogger = key => LoggerMap[key];
@@ -14151,95 +14178,6 @@ DataManager.getTransportStatus = localVersion => {
   return isLatest ? 'valid' : 'outdated';
 };
 
-const Log$5 = getLogger(exports.d0.Transport);
-const BleLogger = getLogger(exports.d0.HdBleTransport);
-const HttpLogger = getLogger(exports.d0.HdTransportHttp);
-
-class TransportManager {
-  static load() {
-    Log$5.debug('transport manager load');
-    this.defaultMessages = DataManager.getProtobufMessages();
-    this.currentMessages = this.defaultMessages;
-  }
-
-  static configure() {
-    return __awaiter(this, void 0, void 0, function* () {
-      try {
-        const env = DataManager.getSettings('env');
-        Log$5.debug('Initializing transports');
-
-        if (env === 'react-native') {
-          if (!this.reactNativeInit) {
-            yield this.transport.init(BleLogger);
-            this.reactNativeInit = true;
-          } else {
-            Log$5.debug('React Native Do Not Initializing transports');
-          }
-        } else {
-          yield this.transport.init(HttpLogger);
-        }
-
-        Log$5.debug('Configuring transports');
-        yield this.transport.configure(JSON.stringify(this.defaultMessages));
-        Log$5.debug('Configuring transports done');
-      } catch (error) {
-        Log$5.debug('Initializing transports error: ', error);
-
-        if (error.code === 'ECONNABORTED') {
-          throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
-        }
-      }
-    });
-  }
-
-  static reconfigure(messages) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (Array.isArray(messages)) {
-        messages = DataManager.getProtobufMessages();
-      }
-
-      if (this.currentMessages === messages || !messages) {
-        return;
-      }
-
-      try {
-        yield this.transport.configure(JSON.stringify(messages));
-        this.currentMessages = messages;
-      } catch (error) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
-      }
-    });
-  }
-
-  static setTransport(TransportConstructor) {
-    const env = DataManager.getSettings('env');
-
-    if (env === 'react-native') {
-      this.transport = new TransportConstructor({
-        scanTimeout: 3000
-      });
-    } else {
-      this.transport = new TransportConstructor();
-    }
-
-    Log$5.debug('set transport: ', this.transport);
-  }
-
-  static getTransport() {
-    return this.transport;
-  }
-
-  static getDefaultMessages() {
-    return this.defaultMessages;
-  }
-
-  static getCurrentMessages() {
-    return this.currentMessages;
-  }
-
-}
-
-TransportManager.reactNativeInit = false;
 const CORE_EVENT = 'CORE_EVENT';
 
 const parseMessage = messageData => {
@@ -14351,6 +14289,7 @@ const DEVICE = {
   PASSPHRASE: 'passphrase',
   PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
   WORD: 'word',
+  SUPPORT_FEATURES: 'support_features',
   FEATURES: 'features'
 };
 
@@ -14372,6 +14311,348 @@ const createFirmwareMessage = (type, payload) => ({
   payload
 });
 
+const Log$6 = getLogger(exports.d0.DevicePool);
+
+const getDiff = (current, descriptors) => {
+  const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
+  const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
+  const changedSessions = descriptors.filter(d => {
+    const currentDescriptor = current.find(x => x.path === d.path);
+
+    if (currentDescriptor) {
+      return currentDescriptor.session !== d.session;
+    }
+
+    return false;
+  });
+  const acquired = changedSessions.filter(d => typeof d.session === 'string');
+  const released = changedSessions.filter(d => typeof d.session !== 'string');
+  const changedDebugSessions = descriptors.filter(d => {
+    const currentDescriptor = current.find(x => x.path === d.path);
+
+    if (currentDescriptor) {
+      return currentDescriptor.debugSession !== d.debugSession;
+    }
+
+    return false;
+  });
+  const debugAcquired = changedSessions.filter(d => typeof d.debugSession === 'string');
+  const debugReleased = changedSessions.filter(d => typeof d.debugSession !== 'string');
+  const didUpdate = connected.length + disconnected.length + changedSessions.length + changedDebugSessions.length > 0;
+  return {
+    connected,
+    disconnected,
+    changedSessions,
+    acquired,
+    released,
+    changedDebugSessions,
+    debugAcquired,
+    debugReleased,
+    didUpdate,
+    descriptors
+  };
+};
+
+class DevicePool extends events.exports {
+  static setConnector(connector) {
+    this.connector = connector;
+  }
+
+  static getDevices(descriptorList, connectId) {
+    var descriptorList_1, descriptorList_1_1;
+
+    var e_1, _a;
+
+    return __awaiter(this, void 0, void 0, function* () {
+      Log$6.debug('get device list');
+      const devices = {};
+      const deviceList = [];
+
+      if (connectId) {
+        const device = this.devicesCache[connectId];
+
+        if (device) {
+          const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
+
+          if (exist) {
+            Log$6.debug('find existed Device: ', connectId);
+            device.updateDescriptor(exist, true);
+            devices[connectId] = device;
+            deviceList.push(device);
+            yield this._checkDevicePool();
+            return {
+              devices,
+              deviceList
+            };
+          }
+
+          Log$6.debug('found device in cache, but path is different: ', connectId);
+        }
+      }
+
+      try {
+        for (descriptorList_1 = __asyncValues(descriptorList); descriptorList_1_1 = yield descriptorList_1.next(), !descriptorList_1_1.done;) {
+          const descriptor = descriptorList_1_1.value;
+          const device = yield this._createDevice(descriptor);
+
+          if (device.features) {
+            const uuid = getDeviceUUID(device.features);
+
+            if (this.devicesCache[uuid]) {
+              const cache = this.devicesCache[uuid];
+              cache.updateDescriptor(descriptor, true);
+            }
+
+            this.devicesCache[uuid] = device;
+            devices[uuid] = device;
+          }
+
+          deviceList.push(device);
+        }
+      } catch (e_1_1) {
+        e_1 = {
+          error: e_1_1
+        };
+      } finally {
+        try {
+          if (descriptorList_1_1 && !descriptorList_1_1.done && (_a = descriptorList_1.return)) yield _a.call(descriptorList_1);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+
+      Log$6.debug('get devices result : ', devices, deviceList);
+      console.log('device poll -> connected: ', this.connectedPool);
+      console.log('device poll -> disconnected: ', this.disconnectPool);
+      yield this._checkDevicePool();
+      return {
+        devices,
+        deviceList
+      };
+    });
+  }
+
+  static _createDevice(descriptor) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let device = this.getDeviceByPath(descriptor.path);
+
+      if (!device) {
+        device = Device.fromDescriptor(descriptor);
+        device.deviceConnector = this.connector;
+        yield device.connect();
+        yield device.initialize();
+        yield device.release();
+      }
+
+      return device;
+    });
+  }
+
+  static _checkDevicePool() {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this._sendConnectMessage();
+
+      this._sendDisconnectMessage();
+    });
+  }
+
+  static _sendConnectMessage() {
+    return __awaiter(this, void 0, void 0, function* () {
+      for (let i = this.connectedPool.length - 1; i >= 0; i--) {
+        const descriptor = this.connectedPool[i];
+        const device = yield this._createDevice(descriptor);
+        Log$6.debug('emit DEVICE.CONNECT: ', device);
+        this.emitter.emit(DEVICE.CONNECT, device);
+        this.connectedPool.splice(i, 1);
+      }
+    });
+  }
+
+  static _sendDisconnectMessage() {
+    for (let i = this.disconnectPool.length - 1; i >= 0; i--) {
+      const descriptor = this.connectedPool[i];
+      const device = this.getDeviceByPath(descriptor.path);
+
+      if (device) {
+        this.emitter.emit(DEVICE.DISCONNECT, device);
+      }
+
+      this.disconnectPool.splice(i, 1);
+    }
+  }
+
+  static reportDeviceChange(upcoming) {
+    const diff = getDiff(this.current || [], upcoming);
+    this.upcoming = upcoming;
+    this.current = this.upcoming;
+    console.log('device pool -> current: ', this.current);
+    console.log('device pool -> upcomming: ', this.upcoming);
+    console.log('DeviceCache.reportDeviceChange diff: ', diff);
+
+    if (!diff.didUpdate) {
+      return;
+    }
+
+    diff.connected.forEach(d => {
+      const device = this.getDeviceByPath(d.path);
+
+      if (!device) {
+        this._addConnectedDeviceToPool(d);
+
+        return;
+      }
+
+      Log$6.debug('emit DEVICE.CONNECT: ', device);
+      this.emitter.emit(DEVICE.CONNECT, device);
+    });
+    diff.disconnected.forEach(d => {
+      this._removeDeviceFromConnectedPool(d.path);
+
+      const device = this.getDeviceByPath(d.path);
+
+      if (!device) {
+        this._addDisconnectedDeviceToPool(d);
+
+        return;
+      }
+
+      Log$6.debug('emit DEVICE.DISCONNECT: ', device);
+      this.emitter.emit(DEVICE.DISCONNECT, device);
+    });
+  }
+
+  static getDeviceByPath(path) {
+    return Object.values(this.devicesCache).find(d => d.originalDescriptor.path === path);
+  }
+
+  static _addConnectedDeviceToPool(descriptor) {
+    const existDescriptorIndex = this.connectedPool.findIndex(d => d.path === descriptor.path);
+
+    if (existDescriptorIndex > -1) {
+      this.connectedPool.splice(existDescriptorIndex, 1, descriptor);
+      return;
+    }
+
+    this.connectedPool.push(descriptor);
+  }
+
+  static _removeDeviceFromConnectedPool(path) {
+    const index = this.connectedPool.findIndex(d => d.path === path);
+
+    if (index > -1) {
+      this.connectedPool.splice(index, 1);
+    }
+  }
+
+  static _addDisconnectedDeviceToPool(descriptor) {
+    const existDescriptorIndex = this.disconnectPool.findIndex(d => d.path === descriptor.path);
+
+    if (existDescriptorIndex > -1) {
+      this.disconnectPool.splice(existDescriptorIndex, 1, descriptor);
+      return;
+    }
+
+    this.disconnectPool.push(descriptor);
+  }
+
+}
+
+DevicePool.current = null;
+DevicePool.upcoming = [];
+DevicePool.connectedPool = [];
+DevicePool.disconnectPool = [];
+DevicePool.devicesCache = {};
+DevicePool.emitter = new events.exports();
+const Log$5 = getLogger(exports.d0.Transport);
+const BleLogger = getLogger(exports.d0.HdBleTransport);
+const HttpLogger = getLogger(exports.d0.HdTransportHttp);
+
+class TransportManager {
+  static load() {
+    Log$5.debug('transport manager load');
+    this.defaultMessages = DataManager.getProtobufMessages();
+    this.currentMessages = this.defaultMessages;
+  }
+
+  static configure() {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        const env = DataManager.getSettings('env');
+        Log$5.debug('Initializing transports');
+
+        if (env === 'react-native') {
+          if (!this.reactNativeInit) {
+            yield this.transport.init(BleLogger, DevicePool.emitter);
+            this.reactNativeInit = true;
+          } else {
+            Log$5.debug('React Native Do Not Initializing transports');
+          }
+        } else {
+          yield this.transport.init(HttpLogger);
+        }
+
+        Log$5.debug('Configuring transports');
+        yield this.transport.configure(JSON.stringify(this.defaultMessages));
+        Log$5.debug('Configuring transports done');
+      } catch (error) {
+        Log$5.debug('Initializing transports error: ', error);
+
+        if (error.code === 'ECONNABORTED') {
+          throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
+        }
+      }
+    });
+  }
+
+  static reconfigure(messages) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (Array.isArray(messages)) {
+        messages = DataManager.getProtobufMessages();
+      }
+
+      if (this.currentMessages === messages || !messages) {
+        return;
+      }
+
+      try {
+        yield this.transport.configure(JSON.stringify(messages));
+        this.currentMessages = messages;
+      } catch (error) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
+      }
+    });
+  }
+
+  static setTransport(TransportConstructor) {
+    const env = DataManager.getSettings('env');
+
+    if (env === 'react-native') {
+      this.transport = new TransportConstructor({
+        scanTimeout: 3000
+      });
+    } else {
+      this.transport = new TransportConstructor();
+    }
+
+    Log$5.debug('set transport: ', this.transport);
+  }
+
+  static getTransport() {
+    return this.transport;
+  }
+
+  static getDefaultMessages() {
+    return this.defaultMessages;
+  }
+
+  static getCurrentMessages() {
+    return this.currentMessages;
+  }
+
+}
+
+TransportManager.reactNativeInit = false;
+
 const assertType = (res, resType) => {
   const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
 
@@ -14523,8 +14804,13 @@ class DeviceCommands {
     }
 
     if (res.type === 'EntropyRequest') ;
+    const isWebusbEnv = DataManager.getSettings('env') === 'webusb';
 
     if (res.type === 'PinMatrixRequest') {
+      if (isWebusbEnv) {
+        return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please unlock your device'));
+      }
+
       return this._promptPin(res.message.type).then(pin => {
         if (pin === '@@ONEKEY_INPUT_PIN_IN_DEVICE') {
           return this._commonCall('BixinPinInputOnDevice');
@@ -14579,7 +14865,7 @@ const UI_REQUEST = {
   FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
   NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device'
 };
-const DEFAULT_DOMAIN = `https://jssdk.onekey.so/${"0.1.25"}/`;
+const DEFAULT_DOMAIN = `https://jssdk.onekey.so/${"0.1.28"}/`;
 const DEFAULT_PRIORITY = 2;
 const initialSettings = {
   configSrc: './data/config.json',
@@ -15073,9 +15359,6 @@ class Device extends events.exports {
 
 }
 
-const cacheDeviceMap = {};
-const Log$2 = getLogger(exports.d0.DeviceList);
-
 class DeviceList extends events.exports {
   constructor() {
     super(...arguments);
@@ -15083,67 +15366,17 @@ class DeviceList extends events.exports {
   }
 
   getDeviceLists(connectId) {
-    var e_1, _a;
-
-    var _b, _c;
+    var _a, _b;
 
     return __awaiter(this, void 0, void 0, function* () {
-      const deviceDiff = yield (_b = this.connector) === null || _b === void 0 ? void 0 : _b.enumerate();
-      const descriptorList = (_c = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _c !== void 0 ? _c : [];
+      const deviceDiff = yield (_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate();
+      const descriptorList = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
       this.devices = {};
-      const deviceList = [];
-      Log$2.debug('get device list');
-
-      if (connectId) {
-        const device = cacheDeviceMap[connectId];
-
-        if (device) {
-          const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
-
-          if (exist) {
-            device.updateDescriptor(exist, true);
-            Log$2.debug('find existed Device: ', connectId);
-            this.devices[connectId] = device;
-            return [device];
-          }
-        }
-      }
-
-      try {
-        for (var descriptorList_1 = __asyncValues(descriptorList), descriptorList_1_1; descriptorList_1_1 = yield descriptorList_1.next(), !descriptorList_1_1.done;) {
-          const descriptor = descriptorList_1_1.value;
-          let device = Device.fromDescriptor(descriptor);
-          device.deviceConnector = this.connector;
-          yield device.connect();
-          yield device.initialize();
-          yield device.release();
-          deviceList.push(device);
-
-          if (device.features) {
-            const uuid = getDeviceUUID(device.features);
-
-            if (cacheDeviceMap[uuid]) {
-              const cache = cacheDeviceMap[uuid];
-              cache === null || cache === void 0 ? void 0 : cache.updateFromCache(device);
-              device = cache;
-            }
-
-            this.devices[uuid] = device;
-            cacheDeviceMap[uuid] = device;
-          }
-        }
-      } catch (e_1_1) {
-        e_1 = {
-          error: e_1_1
-        };
-      } finally {
-        try {
-          if (descriptorList_1_1 && !descriptorList_1_1.done && (_a = descriptorList_1.return)) yield _a.call(descriptorList_1);
-        } finally {
-          if (e_1) throw e_1.error;
-        }
-      }
-
+      const {
+        deviceList,
+        devices
+      } = yield DevicePool.getDevices(descriptorList, connectId);
+      this.devices = devices;
       return deviceList;
     });
   }
@@ -15218,6 +15451,15 @@ class BaseMethod {
     })));
   }
 
+  checkDeviceSupportFeature() {
+    if (!this.device || !this.device.features) return;
+    const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+    this.postMessage(createDeviceMessage(DEVICE.SUPPORT_FEATURES, {
+      inputPinOnSoftware,
+      device: this.device.toMessageObject()
+    }));
+  }
+
   dispose() {}
 
 }
@@ -15228,14 +15470,12 @@ class SearchDevices extends BaseMethod {
   }
 
   run() {
-    var e_1, _a;
-
-    var _b, _c;
+    var _a, _b;
 
     return __awaiter(this, void 0, void 0, function* () {
       yield TransportManager.configure();
-      const deviceDiff = yield (_b = this.connector) === null || _b === void 0 ? void 0 : _b.enumerate();
-      const devicesDescriptor = (_c = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _c !== void 0 ? _c : [];
+      const deviceDiff = yield (_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate();
+      const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
       const env = DataManager.getSettings('env');
 
       if (env === 'react-native') {
@@ -15249,31 +15489,10 @@ class SearchDevices extends BaseMethod {
         });
       }
 
-      const devices = [];
-
-      try {
-        for (var devicesDescriptor_1 = __asyncValues(devicesDescriptor), devicesDescriptor_1_1; devicesDescriptor_1_1 = yield devicesDescriptor_1.next(), !devicesDescriptor_1_1.done;) {
-          const descriptor = devicesDescriptor_1_1.value;
-          const device = Device.fromDescriptor(descriptor);
-          device.deviceConnector = this.connector;
-          yield device.connect();
-          yield device.initialize();
-          yield device.release();
-          devices.push(device);
-        }
-      } catch (e_1_1) {
-        e_1 = {
-          error: e_1_1
-        };
-      } finally {
-        try {
-          if (devicesDescriptor_1_1 && !devicesDescriptor_1_1.done && (_a = devicesDescriptor_1.return)) yield _a.call(devicesDescriptor_1);
-        } finally {
-          if (e_1) throw e_1.error;
-        }
-      }
-
-      return devices.map(device => device.toMessageObject());
+      const {
+        deviceList
+      } = yield DevicePool.getDevices(devicesDescriptor);
+      return deviceList.map(device => device.toMessageObject());
     });
   }
 
@@ -16872,6 +17091,20 @@ class DeviceUpdateReboot extends BaseMethod {
 
 }
 
+class DeviceSupportFeatures extends BaseMethod {
+  init() {}
+
+  run() {
+    if (!this.device.features) return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device not initialized'));
+    const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+    return Promise.resolve({
+      inputPinOnSoftware,
+      device: this.device.toMessageObject()
+    });
+  }
+
+}
+
 class DeviceVerify extends BaseMethod {
   init() {
     validateParams(this.payload, [{
@@ -18869,6 +19102,57 @@ class FirmwareUpdate extends BaseMethod {
 
 }
 
+const Log$2 = getLogger(exports.d0.Method);
+
+class RequestWebUsbDevice extends BaseMethod {
+  init() {
+    this.useDevice = false;
+  }
+
+  run() {
+    var _a, _b;
+
+    return __awaiter(this, void 0, void 0, function* () {
+      yield TransportManager.configure();
+      const env = DataManager.getSettings('env');
+
+      if (env !== 'webusb') {
+        return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Not webusb environment'));
+      }
+
+      const transport = TransportManager.getTransport();
+
+      try {
+        const device = yield transport.requestDevice();
+
+        if (!device) {
+          return yield Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+        }
+
+        const deviceDiff = yield (_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate();
+        const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
+        const {
+          deviceList
+        } = yield DevicePool.getDevices(devicesDescriptor);
+
+        const _device = deviceList.find(d => d.originalDescriptor.path === device.serialNumber);
+
+        if (_device) {
+          return {
+            device: _device.toMessageObject()
+          };
+        }
+
+        return yield Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+      } catch (error) {
+        Log$2.debug(error);
+        return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+      }
+    });
+  }
+
+}
+
 class CheckBridgeStatus extends BaseMethod {
   init() {
     this.useDevice = false;
@@ -18905,6 +19189,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   deviceReset: DeviceReset,
   deviceSettings: DeviceSettings,
   deviceUpdateReboot: DeviceUpdateReboot,
+  deviceSupportFeatures: DeviceSupportFeatures,
   deviceVerify: DeviceVerify,
   deviceWipe: DeviceWipe,
   evmGetAddress: EvmGetAddress,
@@ -18926,6 +19211,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   stellarGetAddress: StellarGetAddress,
   stellarSignTransaction: StellarSignTransaction,
   firmwareUpdate: FirmwareUpdate,
+  requestWebUsbDevice: RequestWebUsbDevice,
   getLogs: CheckBridgeStatus
 });
 
@@ -18965,54 +19251,6 @@ const resolveAfter = (msec, value) => new Promise(resolve => {
 
 const Log$1 = getLogger(exports.d0.DeviceConnector);
 
-const getDiff = (current, descriptors) => {
-  const env = DataManager.getSettings('env');
-
-  if (env === 'react-native') {
-    return {
-      descriptors
-    };
-  }
-
-  const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
-  const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
-  const changedSessions = descriptors.filter(d => {
-    const currentDescriptor = current.find(x => x.path === d.path);
-
-    if (currentDescriptor) {
-      return currentDescriptor.session !== d.session;
-    }
-
-    return false;
-  });
-  const acquired = changedSessions.filter(d => typeof d.session === 'string');
-  const released = changedSessions.filter(d => typeof d.session !== 'string');
-  const changedDebugSessions = descriptors.filter(d => {
-    const currentDescriptor = current.find(x => x.path === d.path);
-
-    if (currentDescriptor) {
-      return currentDescriptor.debugSession !== d.debugSession;
-    }
-
-    return false;
-  });
-  const debugAcquired = changedSessions.filter(d => typeof d.debugSession === 'string');
-  const debugReleased = changedSessions.filter(d => typeof d.debugSession !== 'string');
-  const didUpdate = connected.length + disconnected.length + changedSessions.length + changedDebugSessions.length > 0;
-  return {
-    connected,
-    disconnected,
-    changedSessions,
-    acquired,
-    released,
-    changedDebugSessions,
-    debugAcquired,
-    debugReleased,
-    didUpdate,
-    descriptors
-  };
-};
-
 class DeviceConnector {
   constructor() {
     this.listenTimestamp = 0;
@@ -19021,17 +19259,20 @@ class DeviceConnector {
     this.listening = false;
     TransportManager.load();
     this.transport = TransportManager.getTransport();
+    DevicePool.setConnector(this);
   }
 
   enumerate() {
     return __awaiter(this, void 0, void 0, function* () {
       try {
-        this.upcoming = yield this.transport.enumerate();
+        const descriptors = yield this.transport.enumerate();
+        this.upcoming = descriptors;
 
-        const diff = this._reportDevicesChange();
+        this._reportDevicesChange();
 
-        Log$1.debug('diff result: ', diff);
-        return diff;
+        return {
+          descriptors
+        };
       } catch (error) {
         safeThrowError(error);
       }
@@ -19112,9 +19353,7 @@ class DeviceConnector {
   }
 
   _reportDevicesChange() {
-    const diff = getDiff(this.current || [], this.upcoming);
-    this.current = this.upcoming;
-    return diff;
+    DevicePool.reportDeviceChange(this.upcoming);
   }
 
 }
@@ -19155,6 +19394,8 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
     return Promise.reject(error);
   }
 
+  DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
+
   if (!method.useDevice) {
     try {
       const response = yield method.run();
@@ -19205,11 +19446,17 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
         const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
 
         if (semver__default["default"].valid(versionRange.min) && semver__default["default"].lt(currentVersion, versionRange.min)) {
-          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceFwException, `Device firmware version is too low, please update to ${versionRange.min}`));
+          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodNeedUpgradeFirmware, `Device firmware version is too low, please update to ${versionRange.min}`, {
+            current: currentVersion,
+            require: versionRange.min
+          }));
         }
 
-        if (versionRange.max && semver__default["default"].valid(versionRange.max) && semver__default["default"].gt(currentVersion, versionRange.max)) {
-          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceFwException, `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`));
+        if (versionRange.max && semver__default["default"].valid(versionRange.max) && semver__default["default"].gte(currentVersion, versionRange.max)) {
+          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodDeprecated, `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`, {
+            current: currentVersion,
+            deprecated: versionRange.max
+          }));
         }
       }
 
@@ -19232,6 +19479,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
       }
 
       method.checkFirmwareRelease();
+      method.checkDeviceSupportFeature();
 
       if (_deviceList) {
         yield TransportManager.reconfigure(device.getFirmwareVersion());
@@ -19489,12 +19737,29 @@ const removeDeviceListener = device => {
   device.removeListener(DEVICE.PIN, onDevicePinHandler);
   device.removeListener(DEVICE.BUTTON, onDeviceButtonHandler);
   device.removeListener(DEVICE.FEATURES, onDeviceFeaturesHandler);
+  DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
 };
 
 const closePopup = () => {
   postMessage(createUiMessage(UI_REQUEST$1.CLOSE_UI_WINDOW));
 };
 
+const onDeviceConnectHandler = device => {
+  const env = DataManager.getSettings('env');
+  const deviceObject = env === 'react-native' ? device : device.toMessageObject();
+  postMessage(createDeviceMessage(DEVICE.CONNECT, {
+    device: deviceObject
+  }));
+};
+
+const onDeviceDisconnectHandler = device => {
+  const env = DataManager.getSettings('env');
+  const deviceObject = env === 'react-native' ? device : device.toMessageObject();
+  postMessage(createDeviceMessage(DEVICE.DISCONNECT, {
+    device: deviceObject
+  }));
+};
+
 const onDevicePinHandler = (...[device, type, callback]) => __awaiter(void 0, void 0, void 0, function* () {
   Log.debug('onDevicePinHandler');
   const uiPromise = createUiPromise(UI_RESPONSE.RECEIVE_PIN, device);
@@ -19596,6 +19861,7 @@ const initCore = () => {
 
 const initConnector = () => {
   _connector = new DeviceConnector();
+  DevicePool.emitter.on(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
   return _connector;
 };
 
@@ -19952,6 +20218,19 @@ const readHeader = buffer => {
   };
 };
 
+const readHeaderChunked = buffer => {
+  const sharp1 = buffer.readByte();
+  const sharp2 = buffer.readByte();
+  const typeId = buffer.readUint16();
+  const length = buffer.readUint32();
+  return {
+    sharp1,
+    sharp2,
+    typeId,
+    length
+  };
+};
+
 const decode = byteBuffer => {
   const {
     typeId
@@ -19962,6 +20241,32 @@ const decode = byteBuffer => {
   };
 };
 
+const decodeChunked = bytes => {
+  const byteBuffer = ByteBuffer__default["default"].wrap(bytes, undefined, undefined, true);
+  const {
+    sharp1,
+    sharp2,
+    typeId,
+    length
+  } = readHeaderChunked(byteBuffer);
+
+  if (sharp1 !== MESSAGE_HEADER_BYTE || sharp2 !== MESSAGE_HEADER_BYTE) {
+    throw new Error("Didn't receive expected header signature.");
+  }
+
+  return {
+    length,
+    typeId,
+    restBuffer: byteBuffer
+  };
+};
+
+var decodeProtocol = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  decode: decode,
+  decodeChunked: decodeChunked
+});
+
 function encode(data, options) {
   const {
     addTrezorHeaders,
@@ -20013,17 +20318,21 @@ function buildOne(messages, name, data) {
   });
 }
 
-const buildBuffers = (messages, name, data) => {
+const buildEncodeBuffers = (messages, name, data) => {
   const {
     Message,
     messageType
   } = createMessageFromName(messages, name);
   const buffer = encode$1(Message, data);
-  const encodeBuffers = encode(buffer, {
+  return encode(buffer, {
     addTrezorHeaders: true,
     chunked: true,
     messageType
   });
+};
+
+const buildBuffers = (messages, name, data) => {
+  const encodeBuffers = buildEncodeBuffers(messages, name, data);
   const outBuffers = [];
 
   for (const buf of encodeBuffers) {
@@ -20706,8 +21015,10 @@ var index = {
   check,
   buildOne,
   buildBuffers,
+  buildEncodeBuffers,
   receiveOne,
-  parseConfigure
+  parseConfigure,
+  decodeProtocol
 };
 exports.BUFFER_SIZE = BUFFER_SIZE;
 exports.COMMON_HEADER_SIZE = COMMON_HEADER_SIZE;
@@ -20816,6 +21127,7 @@ class HardwareError extends Error {
     super();
     this.errorCode = HardwareErrorCode.UnknownError;
     this.message = '';
+    this.params = {};
     const errorMessageMapping = HardwareErrorCodeMessage;
     this.message = errorMessageMapping[HardwareErrorCode.UnknownError];
 
@@ -20829,6 +21141,7 @@ class HardwareError extends Error {
         this.message = fillStringWithArguments(message, hardwareError);
       }
 
+      this.params = hardwareError.params;
       this.errorCode = hardwareError.errorCode;
     }
 
@@ -20860,6 +21173,8 @@ const HardwareErrorCode = {
   CallMethodNotResponse: 404,
   CallMethodInvalidParameter: 405,
   FirmwareUpdateDownloadFailed: 406,
+  CallMethodNeedUpgradeFirmware: 407,
+  CallMethodDeprecated: 408,
   NetworkError: 500,
   TransportNotConfigured: 600,
   TransportCallInProgress: 601,
@@ -20911,6 +21226,8 @@ const HardwareErrorCodeMessage = {
   [HardwareErrorCode.CallMethodNotResponse]: 'Method does not responding',
   [HardwareErrorCode.CallMethodInvalidParameter]: 'Call method invalid parameter',
   [HardwareErrorCode.FirmwareUpdateDownloadFailed]: 'Firmware update download failed',
+  [HardwareErrorCode.CallMethodNeedUpgradeFirmware]: 'Call method need upgrade firmware',
+  [HardwareErrorCode.CallMethodDeprecated]: 'Call method is deprecated',
   [HardwareErrorCode.NetworkError]: 'Network request error',
   [HardwareErrorCode.TransportNotConfigured]: 'Transport not configured',
   [HardwareErrorCode.TransportCallInProgress]: 'Transport call in progress',
@@ -20940,14 +21257,15 @@ const HardwareErrorCodeMessage = {
   [HardwareErrorCode.PollingStop]: 'Polling stop'
 };
 
-const TypedError = (hardwareError, message) => {
+const TypedError = (hardwareError, message, params) => {
   if (typeof hardwareError === 'string') {
     return new HardwareError(hardwareError);
   }
 
   return new HardwareError({
     errorCode: hardwareError,
-    message: message !== null && message !== void 0 ? message : ''
+    message: message !== null && message !== void 0 ? message : '',
+    params
   });
 };
 
@@ -20955,7 +21273,8 @@ const serializeError = payload => {
   if (payload && payload.error instanceof HardwareError) {
     return {
       error: payload.error.message,
-      code: payload.error.errorCode
+      code: payload.error.errorCode,
+      params: payload.error.params
     };
   }
 
@@ -44733,6 +45052,7 @@ var IInjectedProviderNames;
     IInjectedProviderNames["ethereum"] = "ethereum";
     IInjectedProviderNames["conflux"] = "conflux";
     IInjectedProviderNames["solana"] = "solana";
+    IInjectedProviderNames["starcoin"] = "starcoin";
     IInjectedProviderNames["sollet"] = "sollet";
     IInjectedProviderNames["near"] = "near";
     IInjectedProviderNames["$private"] = "$private";
@@ -45164,7 +45484,7 @@ function parseOpts(arg) {
 
 
 ;// CONCATENATED MODULE: ../../node_modules/@onekeyfe/cross-inpage-provider-core/dist/versionInfo.js
-const version = '0.0.14';
+const version = '0.0.17';
 const versionBuild = '2020-0101-1';
 /* harmony default export */ const dist_versionInfo = ({
     version,
@@ -45870,6 +46190,12 @@ class JsBridgeSimple extends (/* unused pure expression or super */ null && (JsB
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 
 let postMessageListenerAdded = false;
+/**
+ * When the JsBridgeIframe instance changes, the tag can be changed manually
+ */
+function setPostMessageListenerFlag(value) {
+    postMessageListenerAdded = value;
+}
 function setupPostMessageListener(options = {}) {
     if (postMessageListenerAdded) {
         return;
@@ -46006,6 +46332,7 @@ let frameBridge; // eslint-disable-next-line import/no-mutable-exports
 
 let hostBridge;
 const Log = (0,dist/* getLogger */.jl)(dist/* LoggerNames.SendMessage */.d0.SendMessage);
+const resetListenerFlag = () => setPostMessageListenerFlag(false);
 const createJsBridge = params => {
   const bridge = new JsBridgeIframe(params);
 
@@ -46074,7 +46401,7 @@ const handleMessage = async message => {
       break;
 
     case dist/* DEVICE_EVENT */.Fd:
-      if (message.type === dist/* DEVICE.FEATURES */.Td.FEATURES) {
+      if ([dist/* DEVICE.CONNECT */.Td.CONNECT, dist/* DEVICE.DISCONNECT */.Td.DISCONNECT, dist/* DEVICE.FEATURES */.Td.FEATURES, dist/* DEVICE.SUPPORT_FEATURES */.Td.SUPPORT_FEATURES].includes(message.type)) {
         eventEmitter.emit(message.type, message.payload);
       }
 
@@ -46118,17 +46445,22 @@ const cancel = connectId => {
   });
 };
 
+let prevFrameInstance = null;
+
 const createJSBridge = messageEvent => {
+  var _iframe$instance;
+
   if (messageEvent.origin !== origin) {
     return;
   }
 
-  if (!hostBridge) {
-    var _iframe$instance;
+  if (!hostBridge || prevFrameInstance !== ((_iframe$instance = instance) === null || _iframe$instance === void 0 ? void 0 : _iframe$instance.contentWindow)) {
+    var _iframe$instance2, _iframe$instance3;
 
+    resetListenerFlag();
     createJsBridge({
       isHost: true,
-      remoteFrame: (_iframe$instance = instance) === null || _iframe$instance === void 0 ? void 0 : _iframe$instance.contentWindow,
+      remoteFrame: (_iframe$instance2 = instance) === null || _iframe$instance2 === void 0 ? void 0 : _iframe$instance2.contentWindow,
       remoteFrameName: bridge_config.iframeName,
       selfFrameName: bridge_config.hostName,
       channel: bridge_config.channel,
@@ -46149,6 +46481,7 @@ const createJSBridge = messageEvent => {
         return response;
       }
     });
+    prevFrameInstance = (_iframe$instance3 = instance) === null || _iframe$instance3 === void 0 ? void 0 : _iframe$instance3.contentWindow;
   }
 };
 
@@ -46168,7 +46501,7 @@ const src_init = async settings => {
 
   try {
     await init({ ..._settings,
-      version: "0.1.25"
+      version: "0.1.28"
     });
     return true;
   } catch (e) {