@trezor/connect 9.6.0 → 9.6.1-beta.1

package/lib/device/DeviceCurrentSession.js

@@ -3,8 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceCurrentSession = void 0;
 const protobuf_1 = require("@trezor/protobuf");
 const schema_utils_1 = require("@trezor/schema-utils");
+const transport_1 = require("@trezor/transport");
+const errors_groups_1 = require("@trezor/transport/lib/errors-groups");
 const utils_1 = require("@trezor/utils");
 const constants_1 = require("../constants");
+const DataManager_1 = require("../data/DataManager");
 const events_1 = require("../events");
 const debug_1 = require("../utils/debug");
 const blacklist = {
@@ -15,31 +18,52 @@ const blacklist = {
     DecryptedMessage: ['message', 'address'],
     Features: true,
 };
+const allowedCallsBeforeInitialize = [
+    'Cancel',
+    'Initialize',
+    'GetFeatures',
+    'GetFirmwareHash',
+    'ChangeLanguage',
+    'DataChunkAck',
+    'FirmwareErase',
+    'FirmwareUpload',
+];
 const filterForLog = (type, msg) => blacklist[type] === true
     ? '(redacted...)'
     : (blacklist[type] ?? []).reduce((prev, cur) => ({ ...prev, [cur]: '(redacted...)' }), msg);
 const logger = (0, debug_1.initLog)('DeviceCommands');
+const isExpectedResponse = (response, expected) => (Array.isArray(expected) ? expected : expected.split('|')).includes(response.type);
 const success = (payload) => ({ success: true, payload });
 const error = (error) => ({ success: false, error });
-const fail = (msg, cause) => error(new Error(msg, cause ? { cause } : undefined));
+const fail = (msg) => error(new Error(msg, (0, errors_groups_1.isErrorWithoutDeviceInteraction)(msg) ? { cause: 'transport-error' } : undefined));
+const getFeaturesTimeout = () => DataManager_1.DataManager.getSettings('env') === 'react-native' ? 20_000 : 3_000;
 class DeviceCurrentSession {
     device;
     transport;
-    protocol;
     session;
     disposed;
     callPromise;
     abortController;
-    constructor(device, transport, protocol, session) {
+    constructor(device, transport, session) {
         this.device = device;
         this.transport = transport;
-        this.protocol = protocol;
         this.session = session;
+        transport.deviceEvents.once(device.transportPath, e => {
+            if (!this.disposed) {
+                this.disposed = constants_1.ERRORS.TypedError(e.type === transport_1.TRANSPORT.DEVICE_DISCONNECTED
+                    ? 'Device_Disconnected'
+                    : 'Device_UsedElsewhere');
+                this.abortController?.abort(this.disposed);
+            }
+        });
     }
     isDisposed() {
         return !!this.disposed;
     }
-    async typedCall(type, resType, msg = {}) {
+    async typedCall(type, expectedType, msg = {}) {
+        if (!allowedCallsBeforeInitialize.includes(type) && !this.device?.features?.session_id) {
+            console.error('Runtime', `typedCall: Device not initialized when calling ${type}. call Initialize first`);
+        }
         (0, schema_utils_1.Assert)(protobuf_1.MessagesSchema.MessageType.properties[type], msg);
         this.abortController = new AbortController();
         const { signal } = this.abortController;
@@ -52,15 +76,19 @@ class DeviceCurrentSession {
         if (!response.success)
             throw response.error;
         const { payload } = response;
-        if (!(Array.isArray(resType) ? resType : resType.split('|')).includes(payload.type)) {
+        const receivedType = payload.type;
+        if (isExpectedResponse(payload, expectedType)) {
+            return payload;
+        }
+        else {
             await (0, utils_1.scheduleAction)(abort => this.transport.receive({
                 session: this.session,
-                protocol: this.protocol,
+                protocol: this.device.protocol,
+                thpState: this.device.getThpState(),
                 signal: abort,
             }), { timeout: 500 }).catch(() => { });
-            throw constants_1.ERRORS.TypedError('Runtime', `assertType: Response of unexpected type: ${payload.type}. Should be ${resType}`);
+            throw constants_1.ERRORS.TypedError('Runtime', `assertType: Response of unexpected type: ${receivedType}. Should be ${expectedType}`);
         }
-        return payload;
     }
     needCancelWorkaround() {
         return (this.transport.name === 'BridgeTransport' &&
@@ -68,32 +96,36 @@ class DeviceCurrentSession {
     }
     async callLoop(type, msg, abortPromise) {
         let [name, data] = [type, msg];
-        const { protocol, session } = this;
         let pinUnlocked = false;
         while (true) {
-            if (this.disposed)
-                return error(this.disposed);
-            const callPromise = this.call({ session, name, data, protocol });
-            const abortedDuringCall = await Promise.race([
-                callPromise.then(() => false),
-                abortPromise.then(() => true),
+            const timeout = name === 'GetFeatures' ? getFeaturesTimeout() : undefined;
+            const callPromise = this.call(name, data, timeout);
+            const [abortedDuringCall, response] = await Promise.race([
+                callPromise.then(res => [false, res]),
+                abortPromise.then(res => [true, res]),
             ]);
             if (name === 'ButtonAck' && abortedDuringCall && !this.disposed) {
                 if (this.needCancelWorkaround()) {
                     try {
                         await (0, utils_1.resolveAfter)(1);
                         await this.device.acquire();
-                        await this.device.getCurrentSession().cancelCall(false);
+                        await this.device.getCurrentSession().cancelCall();
                         await this.device.release();
                     }
                     catch {
                     }
                 }
                 else {
-                    await this.cancelCall(false);
+                    await this.transport.send({
+                        name: 'Cancel',
+                        data: {},
+                        session: this.session,
+                        protocol: this.device.protocol,
+                        thpState: this.device.getThpState(),
+                    });
                 }
             }
-            const response = await callPromise;
+            await callPromise;
             if (this.disposed)
                 return error(this.disposed);
             if (!response.success)
@@ -102,6 +134,10 @@ class DeviceCurrentSession {
             switch (res.type) {
                 case 'Failure': {
                     const { code, message } = res.message;
+                    if (name === 'GetFeatures' && code === 'Failure_UnexpectedMessage') {
+                        [name, data] = ['Initialize', {}];
+                        break;
+                    }
                     const err = message ||
                         (code === 'Failure_FirmwareError' && 'Firmware installation failed') ||
                         (code === 'Failure_ActionCancelled' && 'Action cancelled by user') ||
@@ -127,7 +163,7 @@ class DeviceCurrentSession {
                         abortPromise,
                     ]);
                     if (!promptRes.success) {
-                        const cancelRes = await this.cancelCall();
+                        const cancelRes = await this.call('Cancel', {});
                         return cancelRes.success ? promptRes : cancelRes;
                     }
                     pinUnlocked = true;
@@ -140,7 +176,7 @@ class DeviceCurrentSession {
                         abortPromise,
                     ]);
                     if (!promptRes.success) {
-                        const cancelRes = await this.cancelCall();
+                        const cancelRes = await this.call('Cancel', {});
                         return cancelRes.success ? promptRes : cancelRes;
                     }
                     const payload = promptRes.payload.passphraseOnDevice
@@ -155,7 +191,7 @@ class DeviceCurrentSession {
                         abortPromise,
                     ]);
                     if (!promptRes.success) {
-                        const cancelRes = await this.cancelCall();
+                        const cancelRes = await this.call('Cancel', {});
                         return cancelRes.success ? promptRes : cancelRes;
                     }
                     [name, data] = ['WordAck', { word: promptRes.payload }];
@@ -170,9 +206,18 @@ class DeviceCurrentSession {
             }
         }
     }
-    async call(params) {
-        logger.debug('Sending', params.name, filterForLog(params.name, params.data));
-        const result = await this.transport.call(params);
+    async call(name, data, timeout) {
+        if (this.disposed)
+            return Promise.resolve(error(this.disposed));
+        logger.debug('Sending', name, filterForLog(name, data));
+        const result = await this.transport.call({
+            name,
+            data,
+            session: this.session,
+            protocol: this.device.protocol,
+            thpState: this.device.getThpState(),
+            timeout,
+        });
         if (result.success) {
             const { type, message } = result.payload;
             logger.debug('Received', type, filterForLog(type, message));
@@ -180,29 +225,15 @@ class DeviceCurrentSession {
         else {
             logger.warn('Received transport error', result.error, result.message);
         }
-        return result.success ? success(result.payload) : fail(result.error, 'transport-error');
+        return result.success ? success(result.payload) : fail(result.error);
     }
-    async cancelCall(expectResponse = true) {
-        if (this.disposed)
-            return Promise.resolve(error(this.disposed));
-        const { protocol, session } = this;
-        const cancelArgs = { session, name: 'Cancel', data: {}, protocol };
-        const response = expectResponse
-            ? await this.transport.call(cancelArgs)
-            : await this.transport.send(cancelArgs);
-        return response.success ? success(response.payload) : fail(response.error);
+    cancelCall() {
+        return this.call('Cancel', {});
     }
-    async abort(reason, dispose = false) {
+    async abort(reason) {
         this.abortController?.abort(reason);
         await this.callPromise;
-        if (dispose)
-            this.disposed = reason;
-    }
-    async dispose() {
-        if (!this.disposed) {
-            this.disposed = constants_1.ERRORS.TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
-            await this.abort(this.disposed);
-        }
+        this.disposed = reason;
     }
 }
 exports.DeviceCurrentSession = DeviceCurrentSession;

package/lib/device/DeviceList.d.ts

@@ -23,14 +23,14 @@ export interface IDeviceList {
     dispose: DeviceList['dispose'];
 }
 export declare const assertDeviceListConnected: (deviceList: IDeviceList) => asserts deviceList is DeviceList;
-type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | '_sessionsBackgroundUrl' | 'manifest'> & {
+type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | 'manifest'> & {
     messages: Record<string, any>;
 };
 type InitParams = Pick<ConnectSettings, 'transports' | 'pendingTransportEvent' | 'transportReconnect'>;
 export declare class DeviceList extends TypedEmitter<DeviceListEvents> implements IDeviceList {
     private readonly transportManagers;
     private transports;
-    private readonly devices;
+    private devices;
     private deviceCounter;
     private readonly handshakeLock;
     private readonly authPenaltyManager;
@@ -44,14 +44,10 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
         version: string;
         outdated: boolean;
     }[];
-    constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }: ConstructorParams);
+    constructor({ messages, priority, debug, manifest }: ConstructorParams);
     private onDeviceConnected;
-    private onDeviceDisconnected;
-    private onDeviceSessionChanged;
-    private onDeviceRequestRelease;
     private getOrCreateTransportManager;
     init({ transports, transportReconnect, pendingTransportEvent }?: InitParams): Promise<void>;
-    private startTransport;
     private initializeTransport;
     private waitForDevices;
     getDeviceCount(): number;
@@ -60,7 +56,6 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
     getDeviceByPath(path: DeviceUniquePath): Device | undefined;
     getDeviceByStaticState(state: StaticSessionId): Device | undefined;
     dispose(): Promise<void>;
-    private stopTransport;
     enumerate(): Promise<void>;
     addAuthPenalty(device: Device): void;
     removeAuthPenalty(device: Device): void;

package/lib/device/DeviceList.js

@@ -30,30 +30,6 @@ const createAuthPenaltyManager = (priority) => {
     const clear = () => Object.keys(penalizedDevices).forEach(key => delete penalizedDevices[key]);
     return { get, add, remove, clear };
 };
-const createDeviceCollection = () => {
-    let devices = [];
-    const isEqual = (a) => (b) => a.transport === b.transport && a.transportPath === b.transportPath;
-    const get = (transportPath, transport) => devices.find(isEqual({ transport, transportPath }));
-    const all = () => devices;
-    const add = (device) => {
-        const index = devices.findIndex(isEqual(device));
-        if (index >= 0)
-            devices[index] = device;
-        else
-            devices.push(device);
-    };
-    const remove = (transportPath, transport) => {
-        const index = devices.findIndex(isEqual({ transport, transportPath }));
-        const [removed] = index >= 0 ? devices.splice(index, 1) : [undefined];
-        return removed;
-    };
-    const clear = (transport) => {
-        let removed;
-        [removed, devices] = (0, utils_1.arrayPartition)(devices, d => !transport || d.transport === transport);
-        return removed;
-    };
-    return { get, all, add, remove, clear };
-};
 const getTransportInfo = (transport) => ({
     apiType: transport.apiType,
     type: transport.name,
@@ -69,7 +45,7 @@ exports.assertDeviceListConnected = assertDeviceListConnected;
 class DeviceList extends utils_1.TypedEmitter {
     transportManagers = {};
     transports = [];
-    devices = createDeviceCollection();
+    devices = [];
     deviceCounter = Date.now();
     handshakeLock;
     authPenaltyManager;
@@ -92,7 +68,7 @@ class DeviceList extends utils_1.TypedEmitter {
     getActiveTransports() {
         return this.getConnectedTransports().map(getTransportInfo);
     }
-    constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }) {
+    constructor({ messages, priority, debug, manifest }) {
         super();
         const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
         this.handshakeLock = (0, utils_1.getSynchronize)();
@@ -100,7 +76,6 @@ class DeviceList extends utils_1.TypedEmitter {
         this.updateTransports = (0, TransportList_1.createTransportList)({
             messages,
             logger: transportLogger,
-            sessionsBackgroundUrl: _sessionsBackgroundUrl,
             id: manifest?.appName || manifest?.appUrl || 'unknown app',
         });
     }
@@ -110,34 +85,27 @@ class DeviceList extends utils_1.TypedEmitter {
             id: (0, types_1.DeviceUniquePath)(id),
             transport,
             descriptor,
-            listener: lifecycle => this.emit(lifecycle, device),
+            listener: lifecycle => {
+                if (lifecycle === events_1.DEVICE.DISCONNECT) {
+                    this.authPenaltyManager.remove(device);
+                    const index = this.devices.indexOf(device);
+                    if (index >= 0)
+                        this.devices.splice(index, 1);
+                }
+                this.emit(lifecycle, device);
+            },
         });
-        this.devices.add(device);
+        this.devices.push(device);
         const penalty = this.authPenaltyManager.get();
         this.handshakeLock(async () => {
-            if (this.devices.get(descriptor.path, transport)) {
+            if (this.devices.includes(device)) {
                 await device.handshake(penalty);
             }
         });
     }
-    onDeviceDisconnected(descriptor, transport) {
-        const device = this.devices.remove(descriptor.path, transport);
-        device?.disconnect();
-    }
-    onDeviceSessionChanged(descriptor, transport) {
-        const device = this.devices.get(descriptor.path, transport);
-        device?.updateDescriptor(descriptor);
-    }
-    onDeviceRequestRelease(descriptor, transport) {
-        const device = this.devices.get(descriptor.path, transport);
-        device?.usedElsewhere();
-    }
     getOrCreateTransportManager(apiType) {
         if (!this.transportManagers[apiType]) {
-            const manager = new TransportManager_1.TransportManager({
-                startTransport: this.startTransport.bind(this),
-                stopTransport: this.stopTransport.bind(this),
-            });
+            const manager = new TransportManager_1.TransportManager(this.initializeTransport.bind(this));
             manager.on(transport_1.TRANSPORT.START, transport => this.emit(transport_1.TRANSPORT.START, getTransportInfo(transport)));
             manager.on(transport_1.TRANSPORT.ERROR, error => this.emit(transport_1.TRANSPORT.ERROR, { apiType, error }));
             this.transportManagers[apiType] = manager;
@@ -157,20 +125,8 @@ class DeviceList extends utils_1.TypedEmitter {
         }));
         await Promise.all(promises);
     }
-    async startTransport(transport, pendingTransportEvent, signal) {
-        try {
-            await this.initializeTransport(transport, pendingTransportEvent, signal);
-        }
-        catch (err) {
-            this.stopTransport(transport);
-            throw err;
-        }
-    }
     async initializeTransport(transport, pendingTransportEvent, signal) {
         transport.on(transport_1.TRANSPORT.DEVICE_CONNECTED, d => this.onDeviceConnected(d, transport));
-        transport.on(transport_1.TRANSPORT.DEVICE_DISCONNECTED, d => this.onDeviceDisconnected(d, transport));
-        transport.on(transport_1.TRANSPORT.DEVICE_SESSION_CHANGED, d => this.onDeviceSessionChanged(d, transport));
-        transport.on(transport_1.TRANSPORT.DEVICE_REQUEST_RELEASE, d => this.onDeviceRequestRelease(d, transport));
         const enumerateResult = await transport.enumerate({ signal });
         if (!enumerateResult.success) {
             throw new Error(enumerateResult.error);
@@ -211,44 +167,32 @@ class DeviceList extends utils_1.TypedEmitter {
         });
     }
     getDeviceCount() {
-        return this.devices.all().length;
+        return this.devices.length;
     }
     getAllDevices() {
-        return this.devices.all();
+        return this.devices;
     }
     getOnlyDevice() {
-        return this.getDeviceCount() === 1 ? this.devices.all()[0] : undefined;
+        return this.devices.length === 1 ? this.devices[0] : undefined;
     }
     getDeviceByPath(path) {
-        return this.devices.all().find(d => d.getUniquePath() === path);
+        return this.devices.find(d => d.getUniquePath() === path);
     }
     getDeviceByStaticState(state) {
         const deviceId = state.split('@')[1].split(':')[0];
-        return this.devices.all().find(d => d.features?.device_id === deviceId);
+        return this.devices.find(d => d.features?.device_id === deviceId);
     }
     async dispose() {
         this.removeAllListeners();
         const promises = Object.values(this.transportManagers).map(manager => manager.dispose());
         await Promise.all(promises);
     }
-    stopTransport(transport) {
-        const devices = this.devices.clear(transport);
-        devices.forEach(device => {
-            this.emit(events_1.DEVICE.DISCONNECT, device);
-            this.authPenaltyManager.remove(device);
-            device.dispose();
-        });
-        transport?.stop();
-    }
     async enumerate() {
         const promises = this.getConnectedTransports().map(async (transport) => {
             const res = await transport.enumerate();
-            if (!res.success) {
-                return;
+            if (res.success) {
+                transport.handleDescriptorsChange(res.payload);
             }
-            res.payload.forEach(d => {
-                this.devices.get(d.path, transport)?.updateDescriptor(d);
-            });
         });
         await Promise.all(promises);
     }

package/lib/device/TransportManager.d.ts

@@ -4,10 +4,7 @@ type TransportManagerEvents = {
     [TRANSPORT.START]: Transport;
     [TRANSPORT.ERROR]: string;
 };
-type TransportManagerParams = {
-    startTransport: (transport: Transport, pendingTransportEvent: boolean, signal: AbortSignal) => Promise<void>;
-    stopTransport: (transport: Transport) => void;
-};
+type StartTransport = (transport: Transport, pendingTransportEvent: boolean, signal: AbortSignal) => Promise<void>;
 type InitParams = {
     transports: Transport[];
     transportReconnect?: boolean;
@@ -20,8 +17,7 @@ export declare class TransportManager extends TypedEmitter<TransportManagerEvent
     private transportReconnect;
     private upgradeTimeout?;
     private readonly startTransport;
-    private readonly stopTransport;
-    constructor({ startTransport, stopTransport }: TransportManagerParams);
+    constructor(startTransport: StartTransport);
     pending(): Promise<void> | undefined;
     get(): Transport | undefined;
     init({ transports, transportReconnect, pendingTransportEvent }: InitParams): Promise<void>;

package/lib/device/TransportManager.js

@@ -34,11 +34,9 @@ class TransportManager extends utils_1.TypedEmitter {
     transportReconnect = false;
     upgradeTimeout;
     startTransport;
-    stopTransport;
-    constructor({ startTransport, stopTransport }) {
+    constructor(startTransport) {
         super();
         this.startTransport = startTransport;
-        this.stopTransport = stopTransport;
     }
     pending() {
         return this.lock.getPending();
@@ -58,7 +56,7 @@ class TransportManager extends utils_1.TypedEmitter {
             if (activeTransport) {
                 clearTimeout(this.upgradeTimeout);
                 delete this.activeTransport;
-                this.stopTransport(activeTransport);
+                activeTransport.stop();
             }
             return Promise.resolve();
         });
@@ -104,17 +102,23 @@ class TransportManager extends utils_1.TypedEmitter {
                 if (activeTransport) {
                     clearTimeout(this.upgradeTimeout);
                     delete this.activeTransport;
-                    this.stopTransport(activeTransport);
+                    activeTransport.stop();
                 }
                 if (transport) {
-                    await this.startTransport(transport, pendingTransportEvent, abortSignal);
+                    try {
+                        await this.startTransport(transport, pendingTransportEvent, abortSignal);
+                    }
+                    catch (err) {
+                        transport.stop();
+                        throw err;
+                    }
                     transport.on(transport_1.TRANSPORT.ERROR, error => {
                         this.emit(transport_1.TRANSPORT.ERROR, error);
                         clearTimeout(this.upgradeTimeout);
                         this.lock
                             .override('Transport error', async (signal) => {
                             delete this.activeTransport;
-                            this.stopTransport(transport);
+                            transport.stop();
                             if (this.transportReconnect) {
                                 await (0, utils_1.resolveAfter)(1000, signal);
                                 await this.createInitPromise(pendingTransportEvent, signal);

package/lib/device/checkFirmwareRevision.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkFirmwareRevision = void 0;
 const utils_1 = require("@trezor/utils");
 const calculateRevisionForDevice_1 = require("./calculateRevisionForDevice");
-const downloadReleasesMetadata_1 = require("../data/downloadReleasesMetadata");
+const firmwareInfo_1 = require("../data/firmwareInfo");
 const assets_browser_1 = require("../utils/assets-browser");
 const isNotFoundError = (e) => e instanceof assets_browser_1.HttpRequestError && e.response.status === 404;
 const isNodeJSOfflineError = (e) => ['FetchError', 'AbortError'].includes(e.name);
@@ -14,7 +14,7 @@ const isOfflineError = (e) => {
     return isNodeJSOfflineError(e) || isReactNativeOfflineError(e);
 };
 const getOnlineReleaseMetadata = async ({ firmwareVersion, internalModel, }) => {
-    const onlineReleases = await (0, downloadReleasesMetadata_1.downloadReleasesMetadata)({ internal_model: internalModel });
+    const onlineReleases = await (0, firmwareInfo_1.getOnlineReleases)(internalModel);
     return onlineReleases.find(onlineRelease => utils_1.versionUtils.isEqual(onlineRelease.version, firmwareVersion));
 };
 const failFirmwareRevisionCheck = (error, errorPayload) => ({

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

@@ -0,0 +1,2 @@
+export { validateState } from './validateState';
+//# sourceMappingURL=index.d.ts.map

package/lib/device/workflow/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateState = void 0;
+var validateState_1 = require("./validateState");
+Object.defineProperty(exports, "validateState", { enumerable: true, get: function () { return validateState_1.validateState; } });
+//# sourceMappingURL=index.js.map

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

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

package/lib/device/workflow/validateState.js

@@ -0,0 +1,90 @@
+"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 getState = async ({ device, method }) => {
+    if (!device.features)
+        return;
+    if (!device.features.unlocked && method.preauthorized) {
+        if (await device.getCommands().preauthorize(false)) {
+            return;
+        }
+    }
+    const expectedState = device.getState()?.staticSessionId;
+    const { message } = await device.getCurrentSession().typedCall('GetAddress', 'Address', {
+        address_n: [(0, pathUtils_1.toHardened)(44), (0, pathUtils_1.toHardened)(1), (0, pathUtils_1.toHardened)(0), 0, 0],
+        coin_name: 'Testnet',
+        script_type: 'SPENDADDRESS',
+    });
+    const uniqueState = `${message.address}@${device.features.device_id}:${device.getInstance()}`;
+    if (device.features.session_id) {
+        device.setState({ sessionId: device.features.session_id });
+    }
+    if (expectedState && expectedState !== uniqueState) {
+        return uniqueState;
+    }
+    if (!expectedState) {
+        device.setState({ staticSessionId: uniqueState });
+    }
+};
+const MAX_PIN_TRIES = 3;
+const getInvalidDeviceState = async (context) => {
+    for (let i = 0; i < MAX_PIN_TRIES - 1; ++i) {
+        try {
+            return await getState(context);
+        }
+        catch (error) {
+            if (error.message.includes('PIN invalid')) {
+                context.method.postMessage((0, events_1.createUiMessage)(events_1.UI.INVALID_PIN, { device: context.device.toMessageObject() }));
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    return getState(context);
+};
+const validateState = async (context) => {
+    const { device, method } = context;
+    if (!method.useDeviceState) {
+        return;
+    }
+    const isDeviceUnlocked = device.features.unlocked;
+    const isUsingPopup = DataManager_1.DataManager.getSettings('popup');
+    try {
+        let invalidDeviceState = await getInvalidDeviceState(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 getInvalidDeviceState(context);
+                }
+                else {
+                    device.setState({ staticSessionId: invalidDeviceState });
+                    break;
+                }
+            }
+        }
+        else if (invalidDeviceState) {
+            throw constants_1.ERRORS.TypedError('Device_InvalidState');
+        }
+    }
+    catch (error) {
+        device.setState({ sessionId: undefined });
+        return Promise.reject(error);
+    }
+    if (!isDeviceUnlocked && device.features.unlocked) {
+        method.postMessage((0, events_1.createDeviceMessage)(events_1.DEVICE.CHANGED, device.toMessageObject()));
+    }
+};
+exports.validateState = validateState;
+//# sourceMappingURL=validateState.js.map