@onekeyfe/hd-web-sdk 0.0.10 → 0.1.2

package/build/onekey-js-sdk.js

@@ -4215,6 +4215,10 @@ const inject = ({
     stellarSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
       method: 'stellarSignTransaction'
+    })),
+    firmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'firmwareUpdate'
     }))
   };
   return api;
@@ -4772,11 +4776,13 @@ const ERROR_CODES = {
   Method_InvalidParameter: '',
   Call_API: '',
   Call_NotResponse: 'No response data',
+  Method_FirmwareUpdate_DownloadFailed: '',
   Transport_InvalidProtobuf: '',
   Device_FwException: '',
   Device_UnexpectedMode: '',
   Device_CallInProgress: '',
   Device_InitializeFailed: '',
+  Device_Interrupted: 'The device is performing other operations',
   Not_Use_Onekey_Device: 'Please use onekey device',
   Runtime: '',
   Init_NotInitialized: 'Init_NotInitialized',
@@ -4828,7 +4834,7 @@ const colors = {
 };
 const MAX_ENTRIES = 100;
 
-class Log$5 {
+class Log$6 {
   constructor(prefix, enabled) {
     this.prefix = prefix;
     this.enabled = enabled;
@@ -4890,7 +4896,7 @@ class Log$5 {
 const _logs = {};
 
 const initLog = (prefix, enabled) => {
-  const instance = new Log$5(prefix, !!enabled);
+  const instance = new Log$6(prefix, !!enabled);
   _logs[prefix] = instance;
   return instance;
 };
@@ -4904,7 +4910,8 @@ const enableLog = enabled => {
 const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0, function* () {
   const response = yield axios__default["default"].request({
     url,
-    withCredentials: false
+    withCredentials: false,
+    responseType: type === 'binary' ? 'arraybuffer' : 'json'
   });
 
   if (+response.status === 200) {
@@ -4913,7 +4920,7 @@ const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0,
     }
 
     if (type === 'binary') {
-      return response.data.arrayBuffer();
+      return response.data;
     }
 
     return response.data;
@@ -4922,7 +4929,7 @@ const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0,
   throw new Error(`httpRequest error: ${url} ${response.statusText}`);
 });
 
-const httpRequest = (url, _type) => httpRequest$1(url);
+const httpRequest = (url, type) => httpRequest$1(url, type);
 
 const getTimeStamp = () => new Date().getTime();
 
@@ -13896,6 +13903,25 @@ var MessagesJSON = {
   nested: nested
 };
 
+const getReleaseStatus = (releases, currentVersion) => {
+  const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
+
+  if (newVersions.length === 0) {
+    return 'valid';
+  }
+
+  if (newVersions.some(r => r.required)) {
+    return 'required';
+  }
+
+  return 'outdated';
+};
+
+const getReleaseChangelog = (releases, currentVersion) => {
+  const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
+  return newVersions.map(r => r.changelog);
+};
+
 var _a;
 
 class DataManager {
@@ -13975,17 +14001,31 @@ DataManager.getFirmwareStatus = features => {
   }
 
   const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.firmware) !== null && _c !== void 0 ? _c : [];
-  const latestFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
-  if (!latestFirmware) return 'valid';
-  const latestVersion = latestFirmware.version.join('.');
   const currentVersion = deviceFirmwareVersion.join('.');
+  return getReleaseStatus(targetDeviceConfigList, currentVersion);
+};
+
+DataManager.getFirmwareChangelog = features => {
+  var _b, _c;
+
+  const deviceType = getDeviceType(features);
+  const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
 
-  if (semver__default["default"].gt(latestVersion, currentVersion)) {
-    if (latestFirmware.required) return 'required';
-    return 'outdated';
+  if (features.firmware_present === false || deviceType === 'classic' && features.bootloader_mode) {
+    return [];
   }
 
-  return 'valid';
+  const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.firmware) !== null && _c !== void 0 ? _c : [];
+  const currentVersion = deviceFirmwareVersion.join('.');
+  return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+};
+
+DataManager.getFirmwareLeatestRelease = features => {
+  var _b, _c;
+
+  const deviceType = getDeviceType(features);
+  const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.firmware) !== null && _c !== void 0 ? _c : [];
+  return targetDeviceConfigList[targetDeviceConfigList.length - 1];
 };
 
 DataManager.getBLEFirmwareStatus = features => {
@@ -13999,17 +14039,31 @@ DataManager.getBLEFirmwareStatus = features => {
   }
 
   const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.ble) !== null && _c !== void 0 ? _c : [];
-  const latestBLEFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
-  if (!latestBLEFirmware) return 'valid';
-  const latestVersion = latestBLEFirmware.version.join('.');
   const currentVersion = deviceBLEFirmwareVersion.join('.');
+  return getReleaseStatus(targetDeviceConfigList, currentVersion);
+};
+
+DataManager.getBleFirmwareChangelog = features => {
+  var _b, _c;
 
-  if (semver__default["default"].gt(latestVersion, currentVersion)) {
-    if (latestBLEFirmware.required) return 'required';
-    return 'outdated';
+  const deviceType = getDeviceType(features);
+  const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+
+  if (!deviceBLEFirmwareVersion) {
+    return [];
   }
 
-  return 'valid';
+  const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.ble) !== null && _c !== void 0 ? _c : [];
+  const currentVersion = deviceBLEFirmwareVersion.join('.');
+  return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+};
+
+DataManager.getBleFirmwareLeatestRelease = features => {
+  var _b, _c;
+
+  const deviceType = getDeviceType(features);
+  const targetDeviceConfigList = (_c = (_b = _a.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.ble) !== null && _c !== void 0 ? _c : [];
+  return targetDeviceConfigList[targetDeviceConfigList.length - 1];
 };
 
 DataManager.getTransportStatus = localVersion => {
@@ -14021,7 +14075,7 @@ DataManager.getTransportStatus = localVersion => {
   return isLatest ? 'valid' : 'outdated';
 };
 
-const Log$4 = initLog('Transport');
+const Log$5 = initLog('Transport');
 
 class TransportManager {
   static load() {
@@ -14034,24 +14088,24 @@ class TransportManager {
     return __awaiter(this, void 0, void 0, function* () {
       try {
         const env = DataManager.getSettings('env');
-        Log$4.debug('Initializing transports');
+        Log$5.debug('Initializing transports');
 
         if (env === 'react-native') {
           if (!this.reactNativeInit) {
             yield this.transport.init();
             this.reactNativeInit = true;
           } else {
-            Log$4.debug('React Native Do Not Initializing transports');
+            Log$5.debug('React Native Do Not Initializing transports');
           }
         } else {
           yield this.transport.init();
         }
 
-        Log$4.debug('Configuring transports');
+        Log$5.debug('Configuring transports');
         yield this.transport.configure(JSON.stringify(this.defaultMessages));
-        Log$4.debug('Configuring transports done');
+        Log$5.debug('Configuring transports done');
       } catch (error) {
-        Log$4.debug('Initializing transports error: ', error);
+        Log$5.debug('Initializing transports error: ', error);
       }
     });
   }
@@ -14142,7 +14196,8 @@ const UI_REQUEST$1 = {
   REQUEST_BUTTON: 'ui-button',
   CLOSE_UI_WINDOW: 'ui-close_window',
   BLUETOOTH_PERMISSION: 'ui-bluetooth_permission',
-  LOCATION_PERMISSION: 'ui-location_permission'
+  LOCATION_PERMISSION: 'ui-location_permission',
+  FIRMWARE_PROGRESS: 'ui-firmware-progress'
 };
 
 const createUiMessage = (type, payload) => ({
@@ -14154,7 +14209,8 @@ const createUiMessage = (type, payload) => ({
 const IFRAME = {
   INIT: 'iframe-init',
   INIT_BRIDGE: 'iframe-init-bridge',
-  CALL: 'iframe-call'
+  CALL: 'iframe-call',
+  CANCEL: 'iframe-cancel'
 };
 
 const createIFrameMessage = (type, payload) => ({
@@ -14217,7 +14273,7 @@ const assertType = (res, resType) => {
   }
 };
 
-const Log$3 = initLog('DeviceCommands');
+const Log$4 = initLog('DeviceCommands');
 
 class DeviceCommands {
   constructor(device, mainId) {
@@ -14228,8 +14284,16 @@ class DeviceCommands {
   }
 
   dispose() {
+    var _a, _b;
+
     this.disposed = true;
+
+    if (this._cancelableRequest) {
+      this._cancelableRequest();
+    }
+
     this._cancelableRequest = undefined;
+    (_b = (_a = this.transport).cancel) === null || _b === void 0 ? void 0 : _b.call(_a);
   }
 
   call(type, msg = {}) {
@@ -14240,10 +14304,10 @@ class DeviceCommands {
         const promise = this.transport.call(this.mainId, type, msg);
         this.callPromise = promise;
         const res = yield promise;
-        Log$3.debug('[DeviceCommands] [call] Received', res.type);
+        Log$4.debug('[DeviceCommands] [call] Received', res.type);
         return res;
       } catch (error) {
-        Log$3.debug('[DeviceCommands] [call] Received error', error);
+        Log$4.debug('[DeviceCommands] [call] Received error', error);
         throw error;
       }
     });
@@ -14467,7 +14531,7 @@ const parseRunOptions = options => {
   return options;
 };
 
-const Log$2 = initLog('Device');
+const Log$3 = initLog('Device');
 
 class Device extends events.exports {
   constructor(descriptor) {
@@ -14479,7 +14543,6 @@ class Device extends events.exports {
     this.unavailableCapabilities = {};
     this.instance = 0;
     this.internalState = [];
-    this.loaded = false;
     this.needReloadDevice = false;
     this.keepSession = false;
     this.originalDescriptor = descriptor;
@@ -14554,10 +14617,10 @@ class Device extends events.exports {
         if (env === 'react-native') {
           const res = yield (_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.originalDescriptor.id);
           this.mainId = (_b = res.uuid) !== null && _b !== void 0 ? _b : '';
-          Log$2.debug('Expected uuid:', this.mainId);
+          Log$3.debug('Expected uuid:', this.mainId);
         } else {
           this.mainId = yield (_c = this.deviceConnector) === null || _c === void 0 ? void 0 : _c.acquire(this.originalDescriptor.path, this.originalDescriptor.session);
-          Log$2.debug('Expected session id:', this.mainId);
+          Log$3.debug('Expected session id:', this.mainId);
         }
 
         this.updateDescriptor({
@@ -14606,7 +14669,7 @@ class Device extends events.exports {
             session: null
           });
         } catch (err) {
-          Log$2.error('[Device] release error: ', err);
+          Log$3.error('[Device] release error: ', err);
         } finally {
           this.needReloadDevice = true;
         }
@@ -14614,6 +14677,10 @@ class Device extends events.exports {
     });
   }
 
+  getCommands() {
+    return this.commands;
+  }
+
   getInternalState() {
     return this.internalState[this.instance];
   }
@@ -14674,11 +14741,21 @@ class Device extends events.exports {
     }
   }
 
+  updateFromCache(device) {
+    this.mainId = device.mainId;
+    this.commands = device.commands;
+    this.updateDescriptor(device.originalDescriptor);
+
+    if (device.features) {
+      this._updateFeatures(device.features);
+    }
+  }
+
   run(fn, options) {
     return __awaiter(this, void 0, void 0, function* () {
       if (this.runPromise) {
-        Log$2.error('[Device] run error:', 'Device is running');
-        throw TypedError('Device_CallInProgress');
+        this.interruption();
+        Log$3.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
       }
 
       options = parseRunOptions(options);
@@ -14710,14 +14787,10 @@ class Device extends events.exports {
         yield fn();
       }
 
-      if (this.loaded && this.features) {
-        yield this.getFeatures();
-      }
-
       if (!this.keepSession && typeof options.keepSession !== 'boolean' || options.keepSession === false) {
         this.keepSession = false;
         yield this.release();
-        Log$2.debug('release device, mainId: ', this.mainId);
+        Log$3.debug('release device, mainId: ', this.mainId);
       }
 
       if (this.runPromise) {
@@ -14725,13 +14798,19 @@ class Device extends events.exports {
       }
 
       this.runPromise = null;
-
-      if (!this.loaded) {
-        this.loaded = true;
-      }
     });
   }
 
+  interruption() {
+    if (this.commands) {
+      this.commands.dispose();
+    }
+
+    if (this.runPromise) {
+      this.runPromise.reject(TypedError('Device_Interrupted'));
+    }
+  }
+
   getMode() {
     var _a, _b, _c;
 
@@ -14809,6 +14888,9 @@ class Device extends events.exports {
 
 }
 
+const cacheDeviceMap = new Map();
+const Log$2 = initLog('DeviceList');
+
 class DeviceList extends events.exports {
   constructor() {
     super(...arguments);
@@ -14830,7 +14912,7 @@ class DeviceList extends events.exports {
       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;
-          const device = Device.fromDescriptor(descriptor);
+          let device = Device.fromDescriptor(descriptor);
           device.deviceConnector = this.connector;
           yield device.connect();
           yield device.initialize();
@@ -14839,7 +14921,16 @@ class DeviceList extends events.exports {
 
           if (device.features) {
             const uuid = getDeviceUUID(device.features);
+
+            if (cacheDeviceMap.has(uuid)) {
+              const cache = cacheDeviceMap.get(uuid);
+              cache === null || cache === void 0 ? void 0 : cache.updateFromCache(device);
+              device = cache;
+              Log$2.debug('use cache device: ', uuid);
+            }
+
             this.devices[uuid] = device;
+            cacheDeviceMap.set(uuid, device);
           }
         }
       } catch (e_1_1) {
@@ -16221,7 +16312,13 @@ class CheckFirmwareRelease extends BaseMethod {
   run() {
     if (this.device.features) {
       const firmwareStatus = DataManager.getFirmwareStatus(this.device.features);
-      return Promise.resolve(firmwareStatus);
+      const changelog = DataManager.getFirmwareChangelog(this.device.features);
+      const release = DataManager.getFirmwareLeatestRelease(this.device.features);
+      return Promise.resolve({
+        status: firmwareStatus,
+        changelog,
+        release
+      });
     }
 
     return Promise.resolve(null);
@@ -16237,7 +16334,13 @@ class CheckBLEFirmwareRelease extends BaseMethod {
   run() {
     if (this.device.features) {
       const firmwareStatus = DataManager.getBLEFirmwareStatus(this.device.features);
-      return Promise.resolve(firmwareStatus);
+      const changelog = DataManager.getBleFirmwareChangelog(this.device.features);
+      const release = DataManager.getBleFirmwareLeatestRelease(this.device.features);
+      return Promise.resolve({
+        status: firmwareStatus,
+        changelog,
+        release
+      });
     }
 
     return Promise.resolve(null);
@@ -18022,6 +18125,179 @@ class StellarSignTransaction extends BaseMethod {
 
 }
 
+const getBinary = ({
+  features,
+  updateType,
+  version
+}) => __awaiter(void 0, void 0, void 0, function* () {
+  const releaseInfo = getInfo({
+    features,
+    updateType
+  });
+
+  if (!releaseInfo) {
+    throw TypedError('Runtime', 'no firmware found for this device');
+  }
+
+  if (version && !semver__default["default"].eq(releaseInfo.version, version)) {
+    throw TypedError('Runtime', 'firmware version mismatch');
+  }
+
+  const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
+  const fw = yield httpRequest(url, 'binary');
+  return Object.assign(Object.assign({}, releaseInfo), {
+    binary: fw
+  });
+});
+
+const getInfo = ({
+  features,
+  updateType
+}) => {
+  var _a, _b, _c;
+
+  const deviceType = getDeviceType(features);
+  const {
+    deviceMap
+  } = DataManager;
+  const releaseInfo = (_c = (_b = (_a = deviceMap === null || deviceMap === void 0 ? void 0 : deviceMap[deviceType]) === null || _a === void 0 ? void 0 : _a[updateType]) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : null;
+  return releaseInfo;
+};
+
+const postConfirmationMessage = device => {
+  var _a;
+
+  if ((_a = device.features) === null || _a === void 0 ? void 0 : _a.firmware_present) {
+    device.emit(DEVICE.BUTTON, device, {
+      code: 'ButtonRequest_FirmwareUpdate'
+    });
+  }
+};
+
+const postProgressMessage = (device, progress, postMessage) => {
+  postMessage(createUiMessage(UI_REQUEST$1.FIRMWARE_PROGRESS, {
+    device: device.toMessageObject(),
+    progress
+  }));
+};
+
+const uploadFirmware = (updateType, typedCall, postMessage, device, {
+  payload
+}) => __awaiter(void 0, void 0, void 0, function* () {
+  var _a, _b;
+
+  if (((_a = device.features) === null || _a === void 0 ? void 0 : _a.major_version) === 1) {
+    postConfirmationMessage(device);
+    const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
+    yield typedCall(eraseCommand, 'Success', {});
+    postProgressMessage(device, 0, postMessage);
+    const {
+      message
+    } = yield typedCall('FirmwareUpload', 'Success', {
+      payload
+    });
+    return message;
+  }
+
+  if (((_b = device.features) === null || _b === void 0 ? void 0 : _b.major_version) === 2) {
+    postConfirmationMessage(device);
+    const length = payload.byteLength;
+    let response = yield typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], {
+      length
+    });
+
+    while (response.type !== 'Success') {
+      const start = response.message.offset;
+      const end = response.message.offset + response.message.length;
+      const chunk = payload.slice(start, end);
+
+      if (start > 0) {
+        postProgressMessage(device, Math.round(start / length * 100), postMessage);
+      }
+
+      response = yield typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
+        payload: chunk
+      });
+    }
+
+    postProgressMessage(device, 100, postMessage);
+    return response.message;
+  }
+
+  throw TypedError('Runtime', 'uploadFirmware: unknown major_version');
+});
+
+class FirmwareUpdate extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.INITIALIZE];
+    this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
+    const {
+      payload
+    } = this;
+    validateParams(payload, [{
+      name: 'version',
+      type: 'array'
+    }, {
+      name: 'binary',
+      type: 'buffer'
+    }]);
+
+    if (!payload.updateType) {
+      throw TypedError('Method_InvalidParameter', 'updateType is required');
+    }
+
+    this.params = {
+      updateType: payload.updateType
+    };
+
+    if ('version' in payload) {
+      this.params = Object.assign(Object.assign({}, this.params), {
+        version: payload.version
+      });
+    }
+
+    if ('binary' in payload) {
+      this.params = Object.assign(Object.assign({}, this.params), {
+        binary: payload.binary
+      });
+    }
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const {
+        device,
+        params
+      } = this;
+      let binary;
+
+      try {
+        if (params.binary) {
+          binary = this.params.binary;
+        } else {
+          if (!device.features) {
+            throw TypedError('Runtime', 'no features found for this device');
+          }
+
+          const firmware = yield getBinary({
+            features: device.features,
+            version: params.version,
+            updateType: params.updateType
+          });
+          binary = firmware.binary;
+        }
+      } catch (err) {
+        throw TypedError('Method_FirmwareUpdate_DownloadFailed', err);
+      }
+
+      return uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, {
+        payload: binary
+      });
+    });
+  }
+
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
   __proto__: null,
   searchDevices: SearchDevices,
@@ -18061,7 +18337,8 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   solGetAddress: SolGetAddress,
   solSignTransaction: SolSignTransaction,
   stellarGetAddress: StellarGetAddress,
-  stellarSignTransaction: StellarSignTransaction
+  stellarSignTransaction: StellarSignTransaction,
+  firmwareUpdate: FirmwareUpdate
 });
 
 function findMethod(message) {
@@ -18254,6 +18531,8 @@ let _uiPromises = [];
 
 let _callPromise;
 
+const deviceCacheMap = new Map();
+
 const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
   var _a, _b;
 
@@ -18267,6 +18546,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
   try {
     method = findMethod(message);
     method.connector = _connector;
+    method.postMessage = postMessage;
     method.init();
   } catch (error) {
     return Promise.reject(error);
@@ -18435,13 +18715,44 @@ function initDeviceForBle(method) {
     return initDevice(method);
   }
 
-  const device = Device.fromDescriptor({
-    id: method.connectId
-  });
+  let device;
+
+  if (deviceCacheMap.has(method.connectId)) {
+    device = deviceCacheMap.get(method.connectId);
+  } else {
+    device = Device.fromDescriptor({
+      id: method.connectId
+    });
+    deviceCacheMap.set(method.connectId, device);
+  }
+
   device.deviceConnector = _connector;
   return device;
 }
 
+const cancel = connectId => {
+  const env = DataManager.getSettings('env');
+
+  if (connectId) {
+    let device;
+
+    if (env === 'react-native') {
+      device = initDeviceForBle({
+        connectId
+      });
+    } else {
+      device = initDevice({
+        connectId
+      });
+    }
+
+    device === null || device === void 0 ? void 0 : device.interruption();
+  }
+
+  cleanup();
+  closePopup();
+};
+
 const cleanup = () => {
   _uiPromises = [];
   Log.debug('Cleanup...');
@@ -18525,6 +18836,12 @@ class Core extends events.exports {
             const response = yield callAPI(message);
             return response;
           }
+
+        case IFRAME.CANCEL:
+          {
+            cancel(message.payload.connectId);
+            break;
+          }
       }
 
       return Promise.resolve(message);
@@ -44207,7 +44524,15 @@ const uiResponse = response => {
   });
 };
 
-const cancel = () => {};
+const cancel = connectId => {
+  sendMessage({
+    event: dist/* IFRAME.CANCEL */.Bg.CANCEL,
+    type: dist/* IFRAME.CANCEL */.Bg.CANCEL,
+    payload: {
+      connectId
+    }
+  });
+};
 
 const createJSBridge = messageEvent => {
   if (messageEvent.origin !== origin) {