@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/device/workflow/changeLanguage.js

@@ -0,0 +1,62 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { getLanguage } from "../../data/firmwareInfo.js";
+const uploadTranslationData = async (device, payload) => {
+  if (payload === null) {
+    const response = await device.getCurrentSession().typedCall('ChangeLanguage', ['Success'], {
+      data_length: 0
+    });
+    return response.message;
+  }
+  const length = payload.byteLength;
+  device.startPiggybackAck();
+  let response = await device.getCurrentSession().typedCall('ChangeLanguage', ['DataChunkRequest', 'Success'], {
+    data_length: length
+  });
+  while (response.type !== 'Success') {
+    const start = response.message.data_offset;
+    const end = response.message.data_offset + response.message.data_length;
+    const chunk = payload.slice(start, end);
+    response = await device.getCurrentSession().typedCall('DataChunkAck', ['DataChunkRequest', 'Success'], {
+      data_chunk: Buffer.from(chunk).toString('hex')
+    });
+  }
+  await device.stopPiggybackAck();
+  return response.message;
+};
+export const changeLanguage = async ({
+  device,
+  language,
+  binary
+}) => {
+  if (language === 'en-US') {
+    return uploadTranslationData(device, null);
+  }
+  if (binary) {
+    return uploadTranslationData(device, binary);
+  }
+  const version = device.getVersion();
+  if (!version) {
+    throw ERRORS.TypedError('Runtime', 'changeLanguage: device version unknown');
+  }
+  if (!device.firmwareType) {
+    throw ERRORS.TypedError('Runtime', 'changeLanguage: firmware type unknown');
+  }
+  if (!device.currentRelease) {
+    throw ERRORS.TypedError('Runtime', 'changeLanguage: release not found');
+  }
+  const {
+    translations
+  } = device.currentRelease;
+  const languageBinPath = translations[language];
+  const downloadedBinary = await getLanguage(languageBinPath);
+  if (!downloadedBinary) {
+    throw ERRORS.TypedError('Runtime', 'changeLanguage: translation not found');
+  }
+  let dataToSend;
+  if (Buffer.isBuffer(downloadedBinary)) {
+    dataToSend = new Uint8Array(downloadedBinary).buffer;
+  } else {
+    dataToSend = downloadedBinary;
+  }
+  return uploadTranslationData(device, dataToSend);
+};

package/lib/device/workflow/checkFirmwareHash.d.ts

@@ -1,10 +1,12 @@
-import { FirmwareHashCheckResult } from '../../types';
-import { Log } from '../../utils/debug';
-import type { Device } from '../Device';
+import type { FirmwareHashCheckResult } from '@trezor/connect-common';
+import { type Logger } from '@trezor/utils';
+import type { IDevice } from "../../types/idevice.js";
 type Context = {
-    device: Device;
-    logger: Log;
+  device: IDevice;
+  logger: Logger;
 };
-export declare const checkFirmwareHash: ({ device, logger, }: Context) => Promise<FirmwareHashCheckResult | null>;
-export {};
-//# sourceMappingURL=checkFirmwareHash.d.ts.map
+export declare const checkFirmwareHash: ({
+  device,
+  logger
+}: Context) => Promise<FirmwareHashCheckResult | null>;
+export {};

package/lib/device/workflow/checkFirmwareHash.js

@@ -1,50 +1,44 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkFirmwareHash = void 0;
-const crypto_1 = require("crypto");
-const utils_1 = require("@trezor/utils");
-const firmware_1 = require("../../api/firmware");
-const DataManager_1 = require("../../data/DataManager");
-const firmwareInfo_1 = require("../../data/firmwareInfo");
-const firmwareUtils_1 = require("../../utils/firmwareUtils");
+import { randomBytes } from "@noble/hashes/utils.js";
+import { serializeError } from "@trezor/utils";
+import { calculateFirmwareHash, getBinaryOptional, stripFwHeaders } from "../../api/firmware/index.js";
+import { getFirmwareLocation, getReleaseByVersion } from "../../data/firmwareInfo.js";
+import * as settingsStore from "../../data/settingsStore.js";
+import { getFirmwareType } from "../../utils/firmwareUtils.js";
 const createFailResult = (error, errorPayload) => ({
   success: false,
   error,
   errorPayload
 });
-const checkFirmwareHash = async ({
+export const checkFirmwareHash = async ({
   device,
   logger
 }) => {
-  const enabled = DataManager_1.DataManager.getSettings('enableFirmwareHashCheck');
+  const enabled = settingsStore.get('enableFirmwareHashCheck');
   if (!enabled) return createFailResult('check-skipped');
   const firmwareVersion = device.getVersion();
   if (firmwareVersion === undefined || !device.features || device.features.bootloader_mode) {
     return null;
   }
-  const firmwareType = (0, firmwareUtils_1.getFirmwareType)(device.features);
-  const release = await (0, firmwareInfo_1.getReleaseByVersion)(device.features, firmwareVersion, firmwareType);
+  const firmwareType = getFirmwareType(device.features);
+  const release = await getReleaseByVersion(device.features, firmwareVersion, firmwareType);
   if (!release) return createFailResult('unknown-release');
-  const firmwareLocation = (0, firmwareInfo_1.getFirmwareLocation)({
+  const firmwareLocation = getFirmwareLocation({
     firmwareVersion,
     remotePath: release.url,
     deviceModel: device.features.internal_model,
-    firmwareType: (0, firmwareUtils_1.getFirmwareType)(device.features)
+    firmwareType: getFirmwareType(device.features)
   });
   const {
     baseUrl,
     path
   } = firmwareLocation;
-  const timeoutThresholdsPerModel = DataManager_1.DataManager.getSettings('firmwareHashCheckTimeouts');
+  const timeoutThresholdsPerModel = settingsStore.get('firmwareHashCheckTimeouts');
   if (firmwareVersion === undefined || !device.features || device.features.bootloader_mode) {
     return null;
   }
   const checkSupported = !device.unavailableCapabilities.getFirmwareHash;
   if (!checkSupported) return createFailResult('check-unsupported');
-  const firmwareBinary = await (0, firmware_1.getBinaryOptional)({
+  const firmwareBinary = await getBinaryOptional({
     baseUrl,
     path,
     release
@@ -56,15 +50,15 @@ const checkFirmwareHash = async ({
     logger.warn(`Firmware binary for hash check suspiciously small (< 200 b)`);
     return createFailResult('check-unsupported');
   }
-  const strippedBinary = (0, firmware_1.stripFwHeaders)(firmwareBinary.binary);
+  const strippedBinary = stripFwHeaders(firmwareBinary.binary);
   const {
     hash: expectedHash,
     challenge
-  } = (0, firmware_1.calculateFirmwareHash)({
+  } = calculateFirmwareHash({
     internal_model: device.features.internal_model,
     firmwareVersion,
-    fw: strippedBinary,
-    key: (0, crypto_1.randomBytes)(32)
+    fw: Buffer.from(strippedBinary),
+    key: Buffer.from(randomBytes(32))
   });
   try {
     const ts = performance.now();
@@ -87,8 +81,6 @@ const checkFirmwareHash = async ({
       success: true
     };
   } catch (errorPayload) {
-    return createFailResult('other-error', (0, utils_1.serializeError)(errorPayload));
+    return createFailResult('other-error', serializeError(errorPayload));
   }
-};
-exports.checkFirmwareHash = checkFirmwareHash;
-//# sourceMappingURL=checkFirmwareHash.js.map
+};

package/lib/device/workflow/checkFirmwareHashWithRetries.d.ts

@@ -1,9 +1,8 @@
-import { Log } from '../../utils/debug';
-import type { Device } from '../Device';
+import { type Logger } from '@trezor/utils';
+import type { IDevice } from "../../types/idevice.js";
 type Context = {
-    device: Device;
-    logger: Log;
+  device: IDevice;
+  logger: Logger;
 };
 export declare const checkFirmwareHashWithRetries: (context: Context) => Promise<void>;
-export {};
-//# sourceMappingURL=checkFirmwareHashWithRetries.d.ts.map
+export {};

package/lib/device/workflow/checkFirmwareHashWithRetries.js

@@ -1,32 +1,26 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkFirmwareHashWithRetries = void 0;
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../../constants");
-const checkFirmwareHash_1 = require("./checkFirmwareHash");
+import { FIRMWARE } from "@trezor/connect-common";
+import { isArrayMember } from "@trezor/utils";
+import { checkFirmwareHash } from "./checkFirmwareHash.js";
 const PROBE_CHECK_TIME_RETRIES = 4;
 const probeCheckTime = async context => {
   for (let i = 0; i < PROBE_CHECK_TIME_RETRIES; i++) {
-    const result = await (0, checkFirmwareHash_1.checkFirmwareHash)(context);
+    const result = await checkFirmwareHash(context);
     if (result !== null && (result.success || result.error !== 'takes-too-long')) {
       context.device.setAuthenticityChecks(result);
       return;
     }
   }
 };
-const checkFirmwareHashWithRetries = async context => {
+export const checkFirmwareHashWithRetries = async context => {
   const lastResult = context.device.getAuthenticityChecks().firmwareHash;
   const notDoneYet = lastResult === null;
   const attemptsDone = lastResult?.attemptCount ?? 0;
-  if (attemptsDone >= constants_1.FIRMWARE.HASH_CHECK_MAX_ATTEMPTS) return;
+  if (attemptsDone >= FIRMWARE.HASH_CHECK_MAX_ATTEMPTS) return;
   const wasError = lastResult !== null && !lastResult.success;
-  const wasErrorRetriable = wasError && (0, utils_1.isArrayMember)(lastResult.error, constants_1.FIRMWARE.HASH_CHECK_RETRIABLE_ERRORS);
+  const wasErrorRetriable = wasError && isArrayMember(lastResult.error, FIRMWARE.HASH_CHECK_RETRIABLE_ERRORS);
   const lastErrorPayload = wasError ? lastResult?.errorPayload : null;
   if (notDoneYet || wasErrorRetriable) {
-    const result = await (0, checkFirmwareHash_1.checkFirmwareHash)(context);
+    const result = await checkFirmwareHash(context);
     context.device.setAuthenticityChecks(result);
     if (result === null) return;
     result.attemptCount = attemptsDone + 1;
@@ -39,6 +33,4 @@ const checkFirmwareHashWithRetries = async context => {
       };
     }
   }
-};
-exports.checkFirmwareHashWithRetries = checkFirmwareHashWithRetries;
-//# sourceMappingURL=checkFirmwareHashWithRetries.js.map
+};

package/lib/device/workflow/handshake.d.ts

@@ -1,10 +1,13 @@
-import { WorkflowContext } from '../../types/workflow';
-import { Log } from '../../utils/debug';
+import { type Logger } from '@trezor/utils';
+import type { WorkflowContext } from "../../types/workflow.js";
 type Context = {
-    device: WorkflowContext['device'];
-    signal: AbortSignal;
-    logger?: Log;
+  device: WorkflowContext['device'];
+  signal: AbortSignal;
+  logger?: Logger;
 };
-export declare const handshakeCancel: ({ device, logger, signal }: Context) => Promise<void>;
-export {};
-//# sourceMappingURL=handshake.d.ts.map
+export declare const handshakeCancel: ({
+  device,
+  logger,
+  signal
+}: Context) => Promise<void>;
+export {};

package/lib/device/workflow/handshake.js

@@ -1,17 +1,11 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.handshakeCancel = void 0;
-const protocol_1 = require("@trezor/protocol");
-const transport_1 = require("@trezor/transport");
-const utils_1 = require("@trezor/utils");
-const errors_1 = require("../../constants/errors");
+import { TypedError } from "@trezor/connect-common/lib/constants/errors.js";
+import { PROTOCOL_MALFORMED } from "@trezor/protocol/lib/errors.js";
+import { TRANSPORT_ERROR } from "@trezor/transport-common";
+import { resolveAfter, versionUtils } from "@trezor/utils";
 const CANCEL_TIMEOUT = 1_000;
 const ATTEMPTS_LIMIT = 10;
-const isLegacyBridge = transport => transport.name === 'BridgeTransport' && !utils_1.versionUtils.isNewerOrEqual(transport.version, '3.0.0');
-const handshakeCancel = async ({
+const isLegacyBridge = transport => transport.name === 'BridgeTransport' && !versionUtils.isNewerOrEqual(transport.version, '3.0.0');
+export const handshakeCancel = async ({
   device,
   logger,
   signal
@@ -34,30 +28,28 @@ const handshakeCancel = async ({
     logger?.debug(`handshake Cancel read attempt ${attempt}`);
     const result = await device.getCurrentSession().receive({
       signal,
-      timeout
+      timeout: CANCEL_TIMEOUT
     });
-    if (!result.success && result.error.message === transport_1.TRANSPORT_ERROR.ABORTED_BY_TIMEOUT) {
+    if (!result.success && result.error.message === TRANSPORT_ERROR.ABORTED_BY_TIMEOUT) {
       if (isLegacyBridge(device.transport)) {
-        await (0, utils_1.resolveAfter)(501);
+        await resolveAfter(501);
       }
       await device.acquire();
     }
-    if (!result.success && result.error.message !== protocol_1.PROTOCOL_MALFORMED) {
+    if (!result.success && result.error.message !== PROTOCOL_MALFORMED) {
       logger?.debug(`handshake Cancel read error: ${result.error}`);
       return;
     } else if (result.success) {
       logger?.debug(`handshake Cancel read success: ${result.payload.type}`);
       if (result.payload.type === 'Failure' && result.payload.message.code === 'Failure_InvalidProtocol') {
         logger?.debug(`handshake Cancel protocol v2 detected`);
-        await device.setupThp();
+        device.setupThp();
       }
       if (result.payload.type === 'Failure' && result.payload.message.code === 'Failure_Busy') {
-        throw (0, errors_1.TypedError)(result.payload.message.code, result.payload.message.message);
+        throw TypedError(result.payload.message.code, result.payload.message.message);
       }
       return;
     }
   }
   logger?.debug(`handshake Cancel attempts limit reached`);
-};
-exports.handshakeCancel = handshakeCancel;
-//# sourceMappingURL=handshake.js.map
+};

package/lib/device/workflow/trezorPushNotification.d.ts

@@ -1,3 +1,5 @@
-import { TpnWorkflowContext } from '../../types/workflow';
-export declare const trezorPushNotificationHandler: ({ device, message }: TpnWorkflowContext) => Promise<void>;
-//# sourceMappingURL=trezorPushNotification.d.ts.map
+import type { TpnWorkflowContext } from "../../types/workflow.js";
+export declare const trezorPushNotificationHandler: ({
+  device,
+  message
+}: TpnWorkflowContext) => Promise<void>;

package/lib/device/workflow/trezorPushNotification.js

@@ -1,81 +1,73 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.trezorPushNotificationHandler = void 0;
-const protocol_1 = require("@trezor/protocol");
-const utils_1 = require("@trezor/utils");
-const device_1 = require("../../events/device");
-const thp_1 = require("../thp");
+import { DEVICE } from "@trezor/connect-common";
+import { TrezorPushNotificationMode, TrezorPushNotificationType, tpn } from "@trezor/protocol";
+import { resolveAfter } from "@trezor/utils";
+import { getThpChannel } from "../thp/index.js";
 const setupDeviceMode = async (device, mode) => {
-  if (mode === protocol_1.TrezorPushNotificationMode.BootloaderMode && !device.features) {
+  if (mode === TrezorPushNotificationMode.BootloaderMode && !device.features) {
     device.setBusy('rebooting');
     await device.acquire();
     await device.getFeatures();
     await device.release();
   }
-  if (mode === protocol_1.TrezorPushNotificationMode.NormalMode && (!device.features || !device.getThpState())) {
+  if (mode === TrezorPushNotificationMode.NormalMode && (!device.features || !device.getThpState())) {
     device.setBusy('rebooting');
-    await device.setupThp();
+    device.setupThp();
     await device.acquire();
-    await (0, utils_1.resolveAfter)(1000);
-    await (0, thp_1.getThpChannel)(device, false);
+    await resolveAfter(1000);
+    await getThpChannel(device, false);
     if (device.getThpState()?.phase === 'paired') {
       await device.getFeatures();
     } else {
       device.setBusy('thp-locked');
-      device.lifecycle.emit(device_1.DEVICE.CHANGED);
+      device.emitDeviceChanged();
     }
     await device.release();
   }
 };
-const trezorPushNotificationHandler = async ({
+export const trezorPushNotificationHandler = async ({
   device,
   message
 }) => {
-  const decodedResult = protocol_1.tpn.decode(message);
+  const decodedResult = tpn.decode(message);
   if (!decodedResult.success) return;
   const decoded = decodedResult.payload;
-  device.lifecycle.emit(device_1.DEVICE.TREZOR_PUSH_NOTIFICATION, decoded);
+  device.lifecycle.emit(DEVICE.TREZOR_PUSH_NOTIFICATION, decoded);
   const {
     type,
     mode
   } = decoded;
-  const modeChanged = mode === protocol_1.TrezorPushNotificationMode.BootloaderMode && (device.getThpState()?.properties || device.features && !device.features.bootloader_mode) || mode === protocol_1.TrezorPushNotificationMode.NormalMode && device.features?.bootloader_mode;
+  const modeChanged = mode === TrezorPushNotificationMode.BootloaderMode && (device.getThpState()?.properties || device.features && !device.features.bootloader_mode) || mode === TrezorPushNotificationMode.NormalMode && device.features?.bootloader_mode;
   if (modeChanged) {
     device.reset();
-    device.setBusy(mode === protocol_1.TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'rebooting');
-    device.lifecycle.emit(device_1.DEVICE.CHANGED);
+    device.setBusy(mode === TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'rebooting');
+    device.emitDeviceChanged();
   }
   switch (type) {
-    case protocol_1.TrezorPushNotificationType.SETTING_CHANGE:
-    case protocol_1.TrezorPushNotificationType.PIN_CHANGE:
-    case protocol_1.TrezorPushNotificationType.NOTIFY_POWER_STATUS_CHANGE:
+    case TrezorPushNotificationType.SETTING_CHANGE:
+    case TrezorPushNotificationType.PIN_CHANGE:
+    case TrezorPushNotificationType.NOTIFY_POWER_STATUS_CHANGE:
       if (!device.isUsed()) {
         await device.acquire();
         await device.getFeatures();
         await device.release();
       }
       break;
-    case protocol_1.TrezorPushNotificationType.LOCK:
-      device.setBusy(mode === protocol_1.TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'hard-locked');
-      device.lifecycle.emit(device_1.DEVICE.CHANGED);
+    case TrezorPushNotificationType.LOCK:
+      device.setBusy(mode === TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'hard-locked');
+      device.emitDeviceChanged();
       break;
-    case protocol_1.TrezorPushNotificationType.UNLOCK:
+    case TrezorPushNotificationType.UNLOCK:
       await setupDeviceMode(device, decoded.mode);
       break;
-    case protocol_1.TrezorPushNotificationType.SOFTLOCK:
+    case TrezorPushNotificationType.SOFTLOCK:
       device.setBusy('pin-locked');
-      device.lifecycle.emit(device_1.DEVICE.CHANGED);
+      device.emitDeviceChanged();
       break;
-    case protocol_1.TrezorPushNotificationType.SOFTUNLOCK:
+    case TrezorPushNotificationType.SOFTUNLOCK:
       device.setBusy(device.features ? undefined : 'thp-locked');
-      device.lifecycle.emit(device_1.DEVICE.CHANGED);
+      device.emitDeviceChanged();
       break;
     default:
       break;
   }
-};
-exports.trezorPushNotificationHandler = trezorPushNotificationHandler;
-//# sourceMappingURL=trezorPushNotification.js.map
+};

package/lib/device/workflow/validateState.d.ts

@@ -1,3 +1,2 @@
-import { WorkflowContext } from '../../types/workflow';
-export declare const validateState: (context: WorkflowContext) => Promise<undefined>;
-//# sourceMappingURL=validateState.d.ts.map
+import type { WorkflowContext } from "../../types/workflow.js";
+export declare const validateState: (context: WorkflowContext) => Promise<undefined>;

package/lib/device/workflow/validateState.js

@@ -1,21 +1,19 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validateState = void 0;
-const constants_1 = require("../../constants");
-const DataManager_1 = require("../../data/DataManager");
-const events_1 = require("../../events");
-const pathUtils_1 = require("../../utils/pathUtils");
-const thp_1 = require("../thp");
+import { UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { toHardenedPathPart } from "@trezor/crypto-utils";
+import { createStaticSessionId, parseStaticSessionId } from "@trezor/device-utils";
+import { createThpSession } from "../thp/index.js";
 const getStaticSessionId = device => device.getCurrentSession().typedCall('GetAddress', 'Address', {
-  address_n: [(0, pathUtils_1.toHardened)(44), (0, pathUtils_1.toHardened)(1), (0, pathUtils_1.toHardened)(0), 0, 0],
+  address_n: [toHardenedPathPart(44), toHardenedPathPart(1), toHardenedPathPart(0), 0, 0],
   coin_name: 'Testnet',
   script_type: 'SPENDADDRESS'
 }).then(({
   message
-}) => `${message.address}@${device.features.device_id}:${device.getInstance()}`);
+}) => createStaticSessionId({
+  walletDescriptor: message.address,
+  deviceId: device.features.device_id,
+  instance: device.getInstance()
+}));
 const preauthorizeState = ({
   device,
   method
@@ -24,8 +22,13 @@ const preauthorizeState = ({
     return device.getCommands().preauthorize(false);
   }
 };
-const isUnexpectedState = (expected, current) => expected && current && expected.split(':')[0] !== current.split(':')[0];
-const getState = async context => {
+const isUnexpectedState = (expected, current) => {
+  if (!expected || !current) return false;
+  const parsedExpected = parseStaticSessionId(expected);
+  const parsedCurrent = parseStaticSessionId(current);
+  return parsedExpected.walletDescriptor !== parsedCurrent.walletDescriptor || parsedExpected.deviceId !== parsedCurrent.deviceId;
+};
+const validate = async context => {
   const {
     device
   } = context;
@@ -41,7 +44,7 @@ const getState = async context => {
     });
   }
   if (isUnexpectedState(expectedState, uniqueState)) {
-    return uniqueState;
+    throw ERRORS.TypedError('Device_InvalidState');
   }
   if (!expectedState || expectedState !== uniqueState) {
     device.setState({
@@ -50,13 +53,13 @@ const getState = async context => {
   }
 };
 const MAX_PIN_TRIES = 3;
-const getInvalidDeviceState = async context => {
+const validateDeviceState = async context => {
   for (let i = 0; i < MAX_PIN_TRIES - 1; ++i) {
     try {
-      return await getState(context);
+      return await validate(context);
     } catch (error) {
       if (error.message.includes('PIN invalid')) {
-        context.method.postMessage((0, events_1.createUiMessage)(events_1.UI.INVALID_PIN, {
+        context.sendCoreMessage(createUiMessage(UI_REQUEST.INVALID_PIN, {
           device: context.device.toMessageObject()
         }));
       } else {
@@ -64,16 +67,16 @@ const getInvalidDeviceState = async context => {
       }
     }
   }
-  return getState(context).catch(error => {
+  return validate(context).catch(error => {
     if (error.message.includes('PIN invalid')) {
-      context.method.postMessage((0, events_1.createUiMessage)(events_1.UI.INVALID_PIN_ATTEMPTS_DEPLETED, {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.INVALID_PIN_ATTEMPTS_DEPLETED, {
         device: context.device.toMessageObject()
       }));
     }
     throw error;
   });
 };
-const getInvalidThpDeviceState = async context => {
+const validateThpDeviceState = async context => {
   const {
     device,
     method
@@ -110,7 +113,7 @@ const getInvalidThpDeviceState = async context => {
   }
   if (!uniqueState || !currentState?.deriveCardano && method.useCardanoDerivation) {
     const newSessionId = thpState.createNewSessionId();
-    await (0, thp_1.createThpSession)(device, method.useCardanoDerivation);
+    await createThpSession(device, method.useCardanoDerivation);
     uniqueState = await getStaticSessionId(device);
     device.setState({
       sessionId: newSessionId.toString('hex'),
@@ -118,7 +121,7 @@ const getInvalidThpDeviceState = async context => {
     });
   }
   if (isUnexpectedState(expectedState, uniqueState)) {
-    return uniqueState;
+    throw ERRORS.TypedError('Device_InvalidState');
   }
   if (!expectedState) {
     device.setState({
@@ -126,41 +129,16 @@ const getInvalidThpDeviceState = async context => {
     });
   }
 };
-const validateState = async context => {
+export const validateState = async context => {
   const {
-    device,
-    method
+    device
   } = context;
-  if (!method.useDeviceState) {
-    return;
-  }
-  const validate = device.protocol.name === 'v2' ? getInvalidThpDeviceState : getInvalidDeviceState;
   const isDeviceUnlocked = device.features.unlocked;
-  const isUsingPopup = DataManager_1.DataManager.getSettings('popup');
   try {
-    let invalidDeviceState = await validate(context);
-    if (isUsingPopup) {
-      while (invalidDeviceState) {
-        const uiPromise = method.createUiPromise(events_1.UI.INVALID_PASSPHRASE_ACTION, device);
-        method.postMessage((0, events_1.createUiMessage)(events_1.UI.INVALID_PASSPHRASE, {
-          device: device.toMessageObject()
-        }));
-        const uiResp = await uiPromise.promise;
-        if (uiResp.payload) {
-          device.setState({
-            sessionId: undefined
-          });
-          await device.initialize(method.useCardanoDerivation);
-          invalidDeviceState = await validate(context);
-        } else {
-          device.setState({
-            staticSessionId: invalidDeviceState
-          });
-          break;
-        }
-      }
-    } else if (invalidDeviceState) {
-      throw constants_1.ERRORS.TypedError('Device_InvalidState');
+    if (device.protocol.name === 'v2') {
+      await validateThpDeviceState(context);
+    } else {
+      await validateDeviceState(context);
     }
   } catch (error) {
     device.setState({
@@ -169,8 +147,6 @@ const validateState = async context => {
     return Promise.reject(error);
   }
   if (!isDeviceUnlocked && device.features.unlocked) {
-    method.postMessage((0, events_1.createDeviceMessage)(events_1.DEVICE.CHANGED, device.toMessageObject()));
+    device.emitDeviceChanged();
   }
-};
-exports.validateState = validateState;
-//# sourceMappingURL=validateState.js.map
+};