@trezor/connect 9.6.1-beta.2 → 9.6.2-beta.1

package/lib/device/Device.d.ts

@@ -14,9 +14,6 @@ type RunOptions = {
     skipFirmwareChecks?: boolean;
     skipLanguageChecks?: boolean;
 };
-export declare const CANCEL_TIMEOUT = 1000;
-export declare const GET_FEATURES_TIMEOUT = 3000;
-export declare const GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
 type Result<T> = {
     success: true;
     payload: T;
@@ -48,13 +45,16 @@ export interface DeviceEvents {
     };
     [DEVICE.THP_CREDENTIALS_CHANGED]: DeviceThpCredentialsChangedPayload;
 }
-type DeviceLifecycle = typeof DEVICE.CONNECT | typeof DEVICE.CONNECT_UNACQUIRED | typeof DEVICE.DISCONNECT | typeof DEVICE.CHANGED;
-type DeviceLifecycleListener = (lifecycle: DeviceLifecycle) => void;
+interface DeviceLifecycleEvents {
+    [DEVICE.CONNECT]: void;
+    [DEVICE.CONNECT_UNACQUIRED]: void;
+    [DEVICE.CHANGED]: void;
+    [DEVICE.DISCONNECT]: void;
+}
 type DeviceParams = {
     id: DeviceUniquePath;
     transport: Transport;
     descriptor: Descriptor;
-    listener: DeviceLifecycleListener;
 };
 export declare class Device extends TypedEmitter<DeviceEvents> {
     readonly transport: Transport;
@@ -147,17 +147,17 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private availableTranslations;
     private authenticityChecks;
     private readonly uniquePath;
-    private emitLifecycle;
+    readonly lifecycle: TypedEmitter<DeviceLifecycleEvents>;
     private sessionDfd?;
-    handshakeFinished: boolean;
-    constructor({ id, transport, descriptor, listener }: DeviceParams);
+    constructor({ id, transport, descriptor }: DeviceParams);
     private readonly onTransportStopped;
     private readonly onTransportDeviceEvent;
     private getSessionChangePromise;
     private waitAndCompareSession;
     acquire(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<Session, "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session" | "LIBUSB_ERROR_ACCESS">;
     release(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<null, "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "session not found" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session"> | undefined;
-    handshake(delay?: number): Promise<void>;
+    setupThp(): Promise<void>;
+    handshake(): Promise<boolean>;
     private updateDescriptor;
     run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
     interrupt(reason: Error): Promise<void>;

package/lib/device/Device.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Device = exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = exports.GET_FEATURES_TIMEOUT = exports.CANCEL_TIMEOUT = void 0;
+exports.Device = void 0;
 const crypto_1 = require("crypto");
 const device_utils_1 = require("@trezor/device-utils");
 const protocol_1 = require("@trezor/protocol");
@@ -10,6 +10,7 @@ const DeviceCommands_1 = require("./DeviceCommands");
 const constants_1 = require("../constants");
 const DeviceCurrentSession_1 = require("./DeviceCurrentSession");
 const checkFirmwareRevision_1 = require("./checkFirmwareRevision");
+const thp_1 = require("./thp");
 const firmware_1 = require("../api/firmware");
 const DataManager_1 = require("../data/DataManager");
 const coinInfo_1 = require("../data/coinInfo");
@@ -17,12 +18,10 @@ const firmwareInfo_1 = require("../data/firmwareInfo");
 const getLanguage_1 = require("../data/getLanguage");
 const events_1 = require("../events");
 const types_1 = require("../types");
+const handshake_1 = require("./workflow/handshake");
 const debug_1 = require("../utils/debug");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
 const _log = (0, debug_1.initLog)('Device');
-exports.CANCEL_TIMEOUT = 1_000;
-exports.GET_FEATURES_TIMEOUT = 3_000;
-exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = 20_000;
 class Device extends utils_1.TypedEmitter {
     transport;
     transportPath;
@@ -76,12 +75,10 @@ class Device extends utils_1.TypedEmitter {
         firmwareHash: null,
     };
     uniquePath;
-    emitLifecycle;
+    lifecycle = new utils_1.TypedEmitter();
     sessionDfd;
-    handshakeFinished = false;
-    constructor({ id, transport, descriptor, listener }) {
+    constructor({ id, transport, descriptor }) {
         super();
-        this.emitLifecycle = listener;
         this._protocol = protocol_1.v1;
         this.uniquePath = id;
         this.transport = transport;
@@ -175,49 +172,47 @@ class Device extends utils_1.TypedEmitter {
         });
         return this.releasePromise;
     }
-    async handshake(delay) {
-        if (delay) {
-            await (0, utils_1.resolveAfter)(501 + delay);
+    async setupThp() {
+        _log.info('Setup THP device');
+        this._protocol = protocol_1.v2;
+        if (this.transport.name === 'BridgeTransport' &&
+            !utils_1.versionUtils.isNewerOrEqual(this.transport.version, '3.0.0')) {
+            this.unreadableError = 'THP incompatible with bridge ' + this.transport.version;
         }
-        while (true) {
-            if (this.isUsedElsewhere()) {
-                this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
+        else {
+            try {
+                await this.transport.loadMessages('thp', protocol_1.thp.getProtobufDefinitions);
+                this.thp = new protocol_1.thp.ThpState();
             }
-            else {
-                try {
-                    await this.run();
-                }
-                catch (error) {
-                    _log.warn(`device.run error.message: ${error.message}, code: ${error.code}`);
-                    if (error.code === 'Device_NotFound' ||
-                        error.code === 'Device_Disconnected' ||
-                        error.message === transport_1.TRANSPORT_ERROR.DEVICE_NOT_FOUND ||
-                        error.message === transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION ||
-                        error.message === transport_1.TRANSPORT_ERROR.HTTP_ERROR) {
-                    }
-                    else if ((this.possibleHIDdevice &&
-                        error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE) ||
-                        error.message === transport_1.TRANSPORT_ERROR.LIBUSB_ERROR_ACCESS) {
-                        this.unreadableError = error.message;
-                        this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
-                    }
-                    else if (error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE ||
-                        error.message === transport_1.TRANSPORT_ERROR.UNEXPECTED_ERROR ||
-                        error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS ||
-                        error.code === 'Device_UsedElsewhere' ||
-                        error.code === 'Device_InitializeFailed') {
-                        this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
-                    }
-                    else {
-                        await (0, utils_1.resolveAfter)(501);
-                        continue;
-                    }
-                }
+            catch (error) {
+                this.unreadableError = error.message;
             }
-            this.handshakeFinished = true;
-            return;
         }
     }
+    async handshake() {
+        if (this.isUsedElsewhere()) {
+            return true;
+        }
+        try {
+            await this.run();
+        }
+        catch (error) {
+            _log.warn(`device.run error.message: ${error.message}, code: ${error.code}`);
+            if (error.code === 'Device_NotFound' ||
+                error.code === 'Device_Disconnected' ||
+                error.message === transport_1.TRANSPORT_ERROR.DEVICE_NOT_FOUND ||
+                error.message === transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION ||
+                error.message === transport_1.TRANSPORT_ERROR.HTTP_ERROR) {
+                return false;
+            }
+            if ((this.possibleHIDdevice &&
+                error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE) ||
+                error.message === transport_1.TRANSPORT_ERROR.LIBUSB_ERROR_ACCESS) {
+                this.unreadableError = error.message;
+            }
+        }
+        return true;
+    }
     async updateDescriptor(descriptor) {
         this.sessionDfd?.resolve(descriptor.session);
         await Promise.all([this.acquirePromise, this.releasePromise]);
@@ -227,7 +222,7 @@ class Device extends utils_1.TypedEmitter {
         if (!descriptor.session) {
             this.keepTransportSession = false;
         }
-        this.emitLifecycle(events_1.DEVICE.CHANGED);
+        this.lifecycle.emit(events_1.DEVICE.CHANGED);
     }
     run(fn, options = {}) {
         if (this.runPromise) {
@@ -255,7 +250,7 @@ class Device extends utils_1.TypedEmitter {
         })
             .then(() => {
             if (wasUnacquired && !this.isUnacquired()) {
-                this.emitLifecycle(events_1.DEVICE.CONNECT);
+                this.lifecycle.emit(events_1.DEVICE.CONNECT);
             }
         });
         return this.runPromise;
@@ -291,26 +286,23 @@ class Device extends utils_1.TypedEmitter {
         const { staticSessionId, deriveCardano } = this.getState() || {};
         if (acquireNeeded || !staticSessionId || (!deriveCardano && options.useCardanoDerivation)) {
             try {
-                if (fn) {
+                await (0, handshake_1.handshakeCancel)({ device: this, logger: _log, signal: abortSignal });
+                if (this.protocol.name === 'v2') {
+                    const withInteraction = !!fn;
+                    await (0, thp_1.getThpChannel)(this, withInteraction);
+                }
+                else if (fn) {
                     await this.initialize(!!options.useCardanoDerivation);
                 }
                 else {
-                    const isNative = DataManager_1.DataManager.getSettings('env') === 'react-native';
-                    const cancelTimeout = isNative
-                        ? exports.GET_FEATURES_TIMEOUT_REACT_NATIVE
-                        : exports.CANCEL_TIMEOUT;
-                    if (['v1', 'bridge'].includes(this.protocol.name) && !this.possibleHIDdevice) {
-                        _log.debug('sending a preventive cancel on the first encounter with the device');
-                        await Promise.race([
-                            this.getCurrentSession().cancelCall(),
-                            new Promise((_, reject) => setTimeout(reject, cancelTimeout)),
-                        ]).catch(() => this.acquire());
-                    }
                     await this.getFeatures();
                 }
             }
             catch (error) {
                 _log.warn('Device._runInner error: ', error.message);
+                if (error.code === 'Device_ThpPairingTagInvalid') {
+                    return Promise.reject(error);
+                }
                 return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}${error.code ? `, code: ${error.code}` : ''}`));
             }
         }
@@ -632,8 +624,7 @@ class Device extends utils_1.TypedEmitter {
             this.transport.releaseSync(this.sessionAcquired);
             this.sessionAcquired = null;
         }
-        this.emitLifecycle(events_1.DEVICE.DISCONNECT);
-        this.emitLifecycle = () => { };
+        this.lifecycle.emit(events_1.DEVICE.DISCONNECT);
         return this.interrupt(constants_1.ERRORS.TypedError('Device_Disconnected'));
     }
     isBootloader() {

package/lib/device/DeviceCurrentSession.d.ts

@@ -1,10 +1,17 @@
 import { MessagesSchema as Messages } from '@trezor/protobuf';
 import { MessageResponse, Session, Transport } from '@trezor/transport';
 import { Device } from './Device';
+type AbortableOptions = {
+    timeout?: number;
+    signal?: AbortSignal;
+};
 export interface TypedCallProvider {
     typedCall: Messages.TypedCall;
     cancelCall: DeviceCurrentSession['cancelCall'];
     isDisposed: () => boolean;
+    call: DeviceCurrentSession['call'];
+    send: DeviceCurrentSession['send'];
+    receive: DeviceCurrentSession['receive'];
 }
 export declare class DeviceCurrentSession implements TypedCallProvider {
     private readonly device;
@@ -465,6 +472,15 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "ECDHSessionKey";
         message: import("@trezor/protobuf/lib/messages").ECDHSessionKey;
+    } | {
+        type: "DebugLinkGetPairingInfo";
+        message: import("@trezor/protobuf/lib/messages").DebugLinkGetPairingInfo;
+    } | {
+        type: "DebugLinkPairingInfo";
+        message: import("@trezor/protobuf/lib/messages").DebugLinkPairingInfo;
+    } | {
+        type: "DebugLinkToggleThpPairingDialog";
+        message: import("@trezor/protobuf/lib/messages").DebugLinkToggleThpPairingDialog;
     } | {
         type: "DebugLinkResetDebugEvents";
         message: import("@trezor/protobuf/lib/messages").DebugLinkResetDebugEvents;
@@ -819,7 +835,27 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     }>;
     private needCancelWorkaround;
     private callLoop;
-    private call;
+    call<T extends Messages.MessageKey>(name: T, data: Messages.MessagePayload<T>, options?: AbortableOptions): Promise<{
+        success: false;
+        error: Error;
+    } | {
+        success: true;
+        payload: MessageResponse;
+    }>;
+    send<T extends Messages.MessageKey>(name: T, data: Messages.MessagePayload<T>, options?: AbortableOptions): Promise<{
+        success: false;
+        error: Error;
+    } | {
+        success: true;
+        payload: undefined;
+    }>;
+    receive(options?: AbortableOptions): Promise<{
+        success: false;
+        error: Error;
+    } | {
+        success: true;
+        payload: MessageResponse;
+    }>;
     cancelCall(): Promise<{
         success: false;
         error: Error;
@@ -829,4 +865,5 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     }>;
     abort(reason: Error): Promise<void>;
 }
+export {};
 //# sourceMappingURL=DeviceCurrentSession.d.ts.map

package/lib/device/DeviceCurrentSession.js

@@ -99,7 +99,7 @@ class DeviceCurrentSession {
         let pinUnlocked = false;
         while (true) {
             const timeout = name === 'GetFeatures' ? getFeaturesTimeout() : undefined;
-            const callPromise = this.call(name, data, timeout);
+            const callPromise = this.call(name, data, { timeout });
             const [abortedDuringCall, response] = await Promise.race([
                 callPromise.then(res => [false, res]),
                 abortPromise.then(res => [true, res]),
@@ -206,7 +206,7 @@ class DeviceCurrentSession {
             }
         }
     }
-    async call(name, data, timeout) {
+    async call(name, data, options = {}) {
         if (this.disposed)
             return Promise.resolve(error(this.disposed));
         logger.debug('Sending', name, filterForLog(name, data));
@@ -216,7 +216,7 @@ class DeviceCurrentSession {
             session: this.session,
             protocol: this.device.protocol,
             thpState: this.device.getThpState(),
-            timeout,
+            ...options,
         });
         if (result.success) {
             const { type, message } = result.payload;
@@ -225,7 +225,31 @@ class DeviceCurrentSession {
         else {
             logger.warn('Received transport error', result.error, result.message);
         }
-        return result.success ? success(result.payload) : fail(result.error);
+        return result.success ? success(result.payload) : fail(result.message || result.error);
+    }
+    async send(name, data, options = {}) {
+        if (this.disposed)
+            return Promise.resolve(error(this.disposed));
+        const result = await this.transport.send({
+            name,
+            data,
+            session: this.session,
+            protocol: this.device.protocol,
+            thpState: this.device.getThpState(),
+            ...options,
+        });
+        return result.success ? success(result.payload) : fail(result.message || result.error);
+    }
+    async receive(options = {}) {
+        if (this.disposed)
+            return Promise.resolve(error(this.disposed));
+        const result = await this.transport.receive({
+            session: this.session,
+            protocol: this.device.protocol,
+            thpState: this.device.getThpState(),
+            ...options,
+        });
+        return result.success ? success(result.payload) : fail(result.message || result.error);
     }
     cancelCall() {
         return this.call('Cancel', {});

package/lib/device/DeviceList.js

@@ -79,29 +79,27 @@ class DeviceList extends utils_1.TypedEmitter {
             id: manifest?.appName || manifest?.appUrl || 'unknown app',
         });
     }
-    onDeviceConnected(descriptor, transport) {
+    async onDeviceConnected(descriptor, transport) {
         const id = (this.deviceCounter++).toString(16).slice(-8);
-        const device = new Device_1.Device({
-            id: (0, types_1.DeviceUniquePath)(id),
-            transport,
-            descriptor,
-            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.push(device);
+        const device = new Device_1.Device({ id: (0, types_1.DeviceUniquePath)(id), transport, descriptor });
         const penalty = this.authPenaltyManager.get();
-        this.handshakeLock(async () => {
-            if (this.devices.includes(device)) {
-                await device.handshake(penalty);
-            }
+        const stillConnected = await this.handshakeLock(() => (0, utils_1.resolveAfter)(penalty && penalty + 501).then(() => device.handshake()));
+        if (!stillConnected) {
+            return;
+        }
+        this.devices.push(device);
+        device.lifecycle.on(events_1.DEVICE.CONNECT, () => this.emit(events_1.DEVICE.CONNECT, device));
+        device.lifecycle.on(events_1.DEVICE.CHANGED, () => this.emit(events_1.DEVICE.CHANGED, device));
+        device.lifecycle.on(events_1.DEVICE.CONNECT_UNACQUIRED, () => this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device));
+        device.lifecycle.on(events_1.DEVICE.DISCONNECT, () => {
+            device.lifecycle.removeAllListeners();
+            this.authPenaltyManager.remove(device);
+            const index = this.devices.indexOf(device);
+            if (index >= 0)
+                this.devices.splice(index, 1);
+            this.emit(events_1.DEVICE.DISCONNECT, device);
         });
+        this.emit(device.isUnacquired() ? events_1.DEVICE.CONNECT_UNACQUIRED : events_1.DEVICE.CONNECT, device);
     }
     getOrCreateTransportManager(apiType) {
         if (!this.transportManagers[apiType]) {
@@ -132,38 +130,24 @@ class DeviceList extends utils_1.TypedEmitter {
             throw new Error(enumerateResult.error);
         }
         const descriptors = enumerateResult.payload;
-        const waitForDevicesPromise = pendingTransportEvent && descriptors.length
-            ? this.waitForDevices(transport, descriptors, signal)
-            : Promise.resolve();
         transport.handleDescriptorsChange(descriptors);
         transport.listen();
-        await waitForDevicesPromise;
+        if (pendingTransportEvent && descriptors.length) {
+            await this.waitForDevices(transport, signal);
+        }
     }
-    waitForDevices(transport, descriptors, signal) {
+    waitForDevices(transport, signal) {
         const { promise, reject, resolve } = (0, utils_1.createDeferred)();
         const onAbort = () => reject(signal.reason);
         signal.addEventListener('abort', onAbort);
         const onError = (error) => reject(new Error(error));
         transport.once(transport_1.TRANSPORT.ERROR, onError);
         const autoResolveTransportEventTimeout = setTimeout(resolve, 10000);
-        const remaining = descriptors.slice();
-        const onDeviceEvent = (device) => {
-            const index = remaining.findIndex(d => d.path === device.transportPath && transport === device.transport);
-            if (index >= 0)
-                remaining.splice(index, 1);
-            if (!remaining.length)
-                resolve();
-        };
-        this.on(events_1.DEVICE.CONNECT, onDeviceEvent);
-        this.on(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceEvent);
-        this.on(events_1.DEVICE.DISCONNECT, onDeviceEvent);
+        this.handshakeLock(resolve);
         return promise.finally(() => {
             transport.off(transport_1.TRANSPORT.ERROR, onError);
             signal.removeEventListener('abort', onAbort);
             clearTimeout(autoResolveTransportEventTimeout);
-            this.off(events_1.DEVICE.CONNECT, onDeviceEvent);
-            this.off(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceEvent);
-            this.off(events_1.DEVICE.DISCONNECT, onDeviceEvent);
         });
     }
     getDeviceCount() {

package/lib/device/TransportList.d.ts

@@ -1,9 +1,9 @@
-import { Transport } from '@trezor/transport';
+import { NodeUsbTransport, Transport, UdpTransport } from '@trezor/transport';
 import type { AbstractTransportParams } from '@trezor/transport/lib/transports/abstract';
 import { ConnectSettingsTransport } from '../types';
 type Params = AbstractTransportParams & {
     sessionsBackgroundUrl?: string | null;
 };
-export declare const createTransportList: (params: Params) => (existing: Transport[], transports?: ConnectSettingsTransport[]) => Transport[];
+export declare const createTransportList: (params: Params) => (existing: Transport[], transports?: ConnectSettingsTransport[]) => (Transport | NodeUsbTransport | UdpTransport)[];
 export {};
 //# sourceMappingURL=TransportList.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { Device } from '../Device';
+export declare const getThpChannel: (_device: Device, _withInteraction?: boolean) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/device/thp/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThpChannel = void 0;
+const constants_1 = require("../../constants");
+const getThpChannel = async (_device, _withInteraction) => {
+    await new Promise((_, reject) => {
+        reject(constants_1.ERRORS.TypedError('Device_ThpStateMissing'));
+    });
+};
+exports.getThpChannel = getThpChannel;
+//# sourceMappingURL=index.js.map

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

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

package/lib/device/workflow/handshake.js

@@ -0,0 +1,57 @@
+"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 DataManager_1 = require("../../data/DataManager");
+const CANCEL_TIMEOUT = 1_000;
+const CANCEL_TIMEOUT_REACT_NATIVE = 20_000;
+const ATTEMPTS_LIMIT = 10;
+const isLegacyBridge = (transport) => transport.name === 'BridgeTransport' &&
+    !utils_1.versionUtils.isNewerOrEqual(transport.version, '3.0.0');
+const handshakeCancel = async ({ device, logger, signal }) => {
+    if (device.features || device.getThpState()?.properties) {
+        return;
+    }
+    const isNative = DataManager_1.DataManager.getSettings('env') === 'react-native';
+    const cancelTimeout = isNative ? CANCEL_TIMEOUT_REACT_NATIVE : CANCEL_TIMEOUT;
+    logger?.debug('handshake Cancel start');
+    const send = await device
+        .getCurrentSession()
+        .send('Cancel', {}, { signal, timeout: cancelTimeout });
+    if (!send.success) {
+        logger?.debug(`handshake Cancel send error ${send.error}`);
+        return;
+    }
+    logger?.debug('handshake Cancel sent');
+    for (let attempt = 0; attempt < ATTEMPTS_LIMIT; ++attempt) {
+        logger?.debug(`handshake Cancel read attempt ${attempt}`);
+        const result = await device.getCurrentSession().receive({
+            signal,
+            timeout: cancelTimeout,
+        });
+        if (!result.success && result.error.message === transport_1.TRANSPORT_ERROR.ABORTED_BY_TIMEOUT) {
+            if (isLegacyBridge(device.transport)) {
+                await (0, utils_1.resolveAfter)(501);
+            }
+            await device.acquire();
+        }
+        if (!result.success && result.error.message !== protocol_1.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();
+            }
+            return;
+        }
+    }
+    logger?.debug(`handshake Cancel attempts limit reached`);
+};
+exports.handshakeCancel = handshakeCancel;
+//# sourceMappingURL=handshake.js.map

package/lib/events/index.d.ts

@@ -35,6 +35,7 @@ export declare const UI: {
     readonly FIRMWARE_NOT_COMPATIBLE: "ui-device_firmware_not_compatible";
     readonly FIRMWARE_NOT_INSTALLED: "ui-device_firmware_not_installed";
     readonly FIRMWARE_PROGRESS: "ui-firmware-progress";
+    readonly FIRMWARE_PROGRESS_UNEXPECTED_DELAY: "ui-firmware-progress-unexpected-delay";
     readonly FIRMWARE_RECONNECT: "ui-firmware_reconnect";
     readonly FIRMWARE_DISCONNECT: "ui-firmware_disconnect";
     readonly FIRMWARE_DOWNLOADED: "ui-firmware_downloaded";

package/lib/events/ui-request.d.ts

@@ -20,6 +20,7 @@ export declare const UI_REQUEST: {
     readonly FIRMWARE_NOT_COMPATIBLE: "ui-device_firmware_not_compatible";
     readonly FIRMWARE_NOT_INSTALLED: "ui-device_firmware_not_installed";
     readonly FIRMWARE_PROGRESS: "ui-firmware-progress";
+    readonly FIRMWARE_PROGRESS_UNEXPECTED_DELAY: "ui-firmware-progress-unexpected-delay";
     readonly FIRMWARE_RECONNECT: "ui-firmware_reconnect";
     readonly FIRMWARE_DISCONNECT: "ui-firmware_disconnect";
     readonly FIRMWARE_DOWNLOADED: "ui-firmware_downloaded";
@@ -232,6 +233,10 @@ export interface FirmwareProgress {
         progress: number;
     };
 }
+export interface FirmwareProgressUnexpectedDelay {
+    type: typeof UI_REQUEST.FIRMWARE_PROGRESS_UNEXPECTED_DELAY;
+    payload: {};
+}
 export interface FirmwareReconnect {
     type: typeof UI_REQUEST.FIRMWARE_RECONNECT;
     payload: {
@@ -248,7 +253,7 @@ export interface FirmwareDisconnect {
         device: Device;
     };
 }
-export type UiEvent = UiRequestWithoutPayload | UiRequestDeviceAction | UiRequestButton | UiRequestPermission | UiRequestConfirmation | UiRequestSelectDevice | UiRequestUnexpectedDeviceMode | UiRequestSelectAccount | UiRequestSelectFee | UiRequestThpPairing | UpdateCustomFee | BundleProgress<any> | FirmwareProgress | FirmwareException | FirmwareReconnect | FirmwareDisconnect | UiRequestAddressValidation | UiRequestSetOperation | UiRequestFirmwareDownloaded;
+export type UiEvent = UiRequestWithoutPayload | UiRequestDeviceAction | UiRequestButton | UiRequestPermission | UiRequestConfirmation | UiRequestSelectDevice | UiRequestUnexpectedDeviceMode | UiRequestSelectAccount | UiRequestSelectFee | UiRequestThpPairing | UpdateCustomFee | BundleProgress<any> | FirmwareProgress | FirmwareProgressUnexpectedDelay | FirmwareException | FirmwareReconnect | FirmwareDisconnect | UiRequestAddressValidation | UiRequestSetOperation | UiRequestFirmwareDownloaded;
 export type UiEventMessage = UiEvent & {
     event: typeof UI_EVENT;
 };

package/lib/events/ui-request.js

@@ -15,6 +15,7 @@ exports.UI_REQUEST = {
     FIRMWARE_NOT_COMPATIBLE: 'ui-device_firmware_not_compatible',
     FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
     FIRMWARE_PROGRESS: 'ui-firmware-progress',
+    FIRMWARE_PROGRESS_UNEXPECTED_DELAY: 'ui-firmware-progress-unexpected-delay',
     FIRMWARE_RECONNECT: 'ui-firmware_reconnect',
     FIRMWARE_DISCONNECT: 'ui-firmware_disconnect',
     FIRMWARE_DOWNLOADED: 'ui-firmware_downloaded',