@trezor/connect 9.4.1 → 9.4.2-beta.2

package/lib/data/deviceAuthenticityConfigTypes.d.ts

@@ -1,38 +1,38 @@
 import { Static } from '@trezor/schema-utils';
 export type DeviceAuthenticityConfig = Static<typeof DeviceAuthenticityConfig>;
-export declare const DeviceAuthenticityConfig: import("@sinclair/typebox/build/esm/index.mjs").TIntersect<[import("@sinclair/typebox/build/esm/index.mjs").TIntersect<[import("@trezor/schema-utils").TObject<{
-    T2B1: import("@sinclair/typebox/build/esm/index.mjs").TIntersect<[import("@trezor/schema-utils").TObject<{
-        rootPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-        caPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
+export declare const DeviceAuthenticityConfig: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
+    T2B1: import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
+        rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
     }>, import("@trezor/schema-utils").TObject<{
-        debug: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@trezor/schema-utils").TObject<{
-            rootPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-            caPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
+        debug: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils").TObject<{
+            rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
         }>>;
     }>]>;
-    T3B1: import("@sinclair/typebox/build/esm/index.mjs").TIntersect<[import("@trezor/schema-utils").TObject<{
-        rootPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-        caPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
+    T3B1: import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
+        rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
     }>, import("@trezor/schema-utils").TObject<{
-        debug: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@trezor/schema-utils").TObject<{
-            rootPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-            caPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
+        debug: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils").TObject<{
+            rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
         }>>;
     }>]>;
-    T3T1: import("@sinclair/typebox/build/esm/index.mjs").TIntersect<[import("@trezor/schema-utils").TObject<{
-        rootPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-        caPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
+    T3T1: import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
+        rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
     }>, import("@trezor/schema-utils").TObject<{
-        debug: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@trezor/schema-utils").TObject<{
-            rootPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
-            caPubKeys: import("@sinclair/typebox/build/esm/index.mjs").TArray<import("@sinclair/typebox/build/esm/index.mjs").TString>;
+        debug: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils").TObject<{
+            rootPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            caPubKeys: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
         }>>;
     }>]>;
 }>, import("@trezor/schema-utils").TObject<{
-    T1B1: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TUndefined>;
-    T2T1: import("@sinclair/typebox/build/esm/index.mjs").TOptional<import("@sinclair/typebox/build/esm/index.mjs").TUndefined>;
+    T1B1: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    T2T1: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
 }>]>, import("@trezor/schema-utils").TObject<{
-    version: import("@sinclair/typebox/build/esm/index.mjs").TNumber;
-    timestamp: import("@sinclair/typebox/build/esm/index.mjs").TString;
+    version: import("@sinclair/typebox").TNumber;
+    timestamp: import("@sinclair/typebox").TString;
 }>]>;
 //# sourceMappingURL=deviceAuthenticityConfigTypes.d.ts.map

package/lib/data/version.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "9.4.1";
+export declare const VERSION = "9.4.2-beta.2";
 export declare const DEFAULT_DOMAIN: string;
 export declare const CONTENT_SCRIPT_VERSION = 1;
 //# sourceMappingURL=version.d.ts.map

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTENT_SCRIPT_VERSION = exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.4.1';
+exports.VERSION = '9.4.2-beta.2';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 const isBeta = exports.VERSION.includes('beta');
 exports.DEFAULT_DOMAIN = isBeta

package/lib/device/Device.d.ts

@@ -1,11 +1,13 @@
 import { Deferred, TypedEmitter } from '@trezor/utils';
+import { Session } from '@trezor/transport';
 import { TransportProtocol } from '@trezor/protocol';
-import { DeviceCommands, PassphrasePromptResponse } from './DeviceCommands';
+import { DeviceCommands } from './DeviceCommands';
 import { PROTO, NETWORK } from '../constants';
-import { DEVICE, DeviceButtonRequestPayload } from '../events';
+import { DEVICE, DeviceButtonRequestPayload, UiResponsePin, UiResponsePassphrase, UiResponseWord } from '../events';
 import { type Transport, type Descriptor } from '@trezor/transport';
 import { Device as DeviceTyped, DeviceFirmwareStatus, DeviceState, Features, ReleaseInfo, UnavailableCapabilities, FirmwareType, VersionArray, KnownDevice } from '../types';
 import { IStateStorage } from './StateStorage';
+import type { PromptCallback } from './prompts';
 export type RunOptions = {
     skipFinalReload?: boolean;
     waiting?: boolean;
@@ -17,9 +19,9 @@ export type RunOptions = {
 export declare const GET_FEATURES_TIMEOUT = 3000;
 export declare const GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
 export interface DeviceEvents {
-    [DEVICE.PIN]: (device: Device, b: PROTO.PinMatrixRequestType | undefined, callback: (err: any, pin: string) => void) => void;
-    [DEVICE.WORD]: (device: Device, b: PROTO.WordRequestType, callback: (err: any, word: string) => void) => void;
-    [DEVICE.PASSPHRASE]: (device: Device, callback: (response: PassphrasePromptResponse) => void) => void;
+    [DEVICE.PIN]: (device: Device, type: PROTO.PinMatrixRequestType | undefined, callback: PromptCallback<UiResponsePin['payload']>) => void;
+    [DEVICE.WORD]: (device: Device, type: PROTO.WordRequestType, callback: PromptCallback<UiResponseWord['payload']>) => void;
+    [DEVICE.PASSPHRASE]: (device: Device, callback: PromptCallback<UiResponsePassphrase['payload']>) => void;
     [DEVICE.PASSPHRASE_ON_DEVICE]: () => void;
     [DEVICE.BUTTON]: (device: Device, payload: DeviceButtonRequestPayload) => void;
     [DEVICE.ACQUIRED]: () => void;
@@ -36,9 +38,10 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private acquirePromise?;
     private releasePromise?;
     private runPromise?;
-    private transportSession?;
+    transportSession?: Session | null;
     keepTransportSession: boolean;
     commands?: DeviceCommands;
+    private cancelableAction?;
     loaded: boolean;
     inconsistent: boolean;
     firstRunPromise: Deferred<boolean>;
@@ -61,6 +64,8 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     cleanup(): Promise<void>;
     run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
     override(error: Error): Promise<void>;
+    setCancelableAction(callback: NonNullable<typeof this.cancelableAction>): void;
+    clearCancelableAction(): void;
     interruptionFromUser(error: Error): Promise<void>;
     interruptionFromOutside(): void;
     _runInner<X>(fn: (() => Promise<X>) | undefined, options: RunOptions): Promise<void>;
@@ -84,9 +89,9 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
         message: string;
     }>;
     private _uploadTranslationData;
-    _updateFeatures(feat: Features): void;
+    private _updateFeatures;
     isUnacquired(): boolean;
-    disconnect(): void;
+    disconnect(): Promise<void>;
     isBootloader(): boolean;
     isInitialized(): boolean;
     isSeedless(): boolean;
@@ -99,11 +104,14 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     isRunning(): boolean;
     isLoaded(): boolean;
     waitForFirstRun(): Promise<boolean>;
-    getDevicePath(): `${number}`;
+    getDevicePath(): import("@trezor/transport/lib/types").PathPublic;
     isT1(): boolean;
     hasUnexpectedMode(allow: string[], require: string[]): "ui-device_bootloader_mode" | "ui-device_not_in_bootloader_mode" | "ui-device_not_initialized" | "ui-device_seedless" | null;
     updateDescriptor(descriptor: Descriptor): void;
     dispose(): Promise<{
+        success: false;
+        error: "session not found";
+    } | {
         success: false;
         error: "Network request failed";
     } | {
@@ -115,9 +123,6 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     } | {
         success: false;
         error: "unexpected error";
-    } | {
-        success: false;
-        error: "session not found";
     } | {
         success: false;
         error: "Aborted by timeout";
@@ -139,6 +144,5 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     } | import("@trezor/transport/lib/types").Success<void> | undefined>;
     getMode(): "normal" | "bootloader" | "initialize" | "seedless";
     toMessageObject(): DeviceTyped;
-    legacyForceRelease(): Promise<void>;
 }
 //# sourceMappingURL=Device.d.ts.map

package/lib/device/Device.js

@@ -142,15 +142,27 @@ class Device extends utils_1.TypedEmitter {
             await this.releasePromise;
         }
     }
+    setCancelableAction(callback) {
+        this.cancelableAction = (e) => callback(e)
+            .catch(e => {
+            _log.debug('cancelableAction error', e);
+        })
+            .finally(() => {
+            this.clearCancelableAction();
+        });
+    }
+    clearCancelableAction() {
+        this.cancelableAction = undefined;
+    }
     async interruptionFromUser(error) {
+        var _a, _b;
         _log.debug('interruptionFromUser');
+        await ((_a = this.cancelableAction) === null || _a === void 0 ? void 0 : _a.call(this, error));
+        await ((_b = this.commands) === null || _b === void 0 ? void 0 : _b.cancel());
         if (this.runPromise) {
             this.runPromise.reject(error);
             delete this.runPromise;
         }
-        if (this.commands) {
-            await this.commands.cancel();
-        }
     }
     interruptionFromOutside() {
         _log.debug('interruptionFromOutside');
@@ -161,7 +173,9 @@ class Device extends utils_1.TypedEmitter {
             this.runPromise.reject(constants_1.ERRORS.TypedError('Device_UsedElsewhere'));
             delete this.runPromise;
         }
-        this.transport.releaseDevice(this.originalDescriptor.path);
+        if (this.originalDescriptor.session) {
+            this.transport.releaseDevice(this.originalDescriptor.session);
+        }
     }
     async _runInner(fn, options) {
         var _a, _b;
@@ -446,8 +460,7 @@ class Device extends utils_1.TypedEmitter {
     disconnect() {
         _log.debug('Disconnect cleanup');
         this.transportSession = null;
-        this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
-        delete this.runPromise;
+        return this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
     }
     isBootloader() {
         return this.features && !!this.features.bootloader_mode;
@@ -527,12 +540,12 @@ class Device extends utils_1.TypedEmitter {
         };
     }
     async dispose() {
+        var _a, _b;
         this.removeAllListeners();
         if (this.isUsedHere() && this.transportSession) {
             try {
-                if (this.commands) {
-                    await this.commands.cancel();
-                }
+                await ((_a = this.cancelableAction) === null || _a === void 0 ? void 0 : _a.call(this));
+                await ((_b = this.commands) === null || _b === void 0 ? void 0 : _b.cancel());
                 return this.transport.release({
                     session: this.transportSession,
                     path: this.originalDescriptor.path,
@@ -596,13 +609,6 @@ class Device extends utils_1.TypedEmitter {
             authenticityChecks: this.authenticityChecks,
         };
     }
-    async legacyForceRelease() {
-        if (this.isUsedHere()) {
-            await this.acquire();
-            await this.getFeatures();
-            await this.release();
-        }
-    }
 }
 exports.Device = Device;
 //# sourceMappingURL=Device.js.map

package/lib/device/DeviceCommands.d.ts

@@ -13,19 +13,12 @@ type TypedCallResponseMap = {
     [K in keyof MessageType]: TypedPayload<K>;
 };
 type DefaultPayloadMessage = TypedCallResponseMap[keyof MessageType];
-export type PassphrasePromptResponse = {
-    passphrase?: string;
-    passphraseOnDevice?: boolean;
-    cache?: boolean;
-};
 export declare class DeviceCommands {
     device: Device;
     transport: Transport;
     transportSession: Session;
     disposed: boolean;
     callPromise?: ReturnType<Transport['call']>;
-    _cancelableRequest?: (error?: any) => void;
-    _cancelableRequestBySend?: boolean;
     constructor(device: Device, transport: Transport, transportSession: Session);
     dispose(): void;
     isDisposed(): boolean;
@@ -78,15 +71,52 @@ export declare class DeviceCommands {
     _commonCall(type: MessageKey, msg?: DefaultPayloadMessage['message']): Promise<DefaultPayloadMessage>;
     _filterCommonTypes(res: DefaultPayloadMessage): Promise<DefaultPayloadMessage>;
     private _getAddress;
-    _promptPin(type?: Messages.PinMatrixRequestType): Promise<string>;
-    _promptPassphrase(): Promise<PassphrasePromptResponse>;
-    _promptWord(type: Messages.WordRequestType): Promise<string>;
     getAccountDescriptor(coinInfo: CoinInfo, indexOrPath: number | number[], derivationType?: Messages.CardanoDerivationType): Promise<{
         descriptor: string;
         legacyXpub?: string;
         address_n: number[];
         descriptorChecksum?: string;
     }>;
+    cancelWithFallback(): Promise<{
+        readonly success: false;
+        readonly error: "session not found";
+    } | import("@trezor/transport/lib/types").Success<import("@trezor/protobuf").MessageFromTrezor> | {
+        success: false;
+        error: "Network request failed";
+    } | {
+        success: false;
+        error: "Wrong result type.";
+    } | {
+        success: false;
+        error: "other call in progress";
+    } | {
+        success: false;
+        error: "Malformed protocol format";
+    } | {
+        success: false;
+        error: "device disconnected during action";
+    } | {
+        success: false;
+        error: "unexpected error";
+    } | {
+        success: false;
+        error: "Aborted by timeout";
+    } | {
+        success: false;
+        error: "Aborted by signal";
+    } | {
+        success: false;
+        error: "This transport can not be used in this environment";
+    } | {
+        success: false;
+        error: "device not found";
+    } | {
+        success: false;
+        error: "Unable to open device";
+    } | {
+        success: false;
+        error: "A transfer error has occurred.";
+    } | import("@trezor/transport/lib/types").Success<undefined> | undefined>;
     cancel(): Promise<void>;
 }
 export type TypedCall = DeviceCommands['typedCall'];

package/lib/device/DeviceCommands.js

@@ -14,6 +14,7 @@ const coinInfo_1 = require("../data/coinInfo");
 const debug_1 = require("../utils/debug");
 const schema_utils_1 = require("@trezor/schema-utils");
 const resolveDescriptorForTaproot_1 = require("./resolveDescriptorForTaproot");
+const prompts_1 = require("./prompts");
 const logger = (0, debug_1.initLog)('DeviceCommands');
 const assertType = (res, resType) => {
     const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
@@ -45,7 +46,6 @@ class DeviceCommands {
     }
     dispose() {
         this.disposed = true;
-        this._cancelableRequest = undefined;
     }
     isDisposed() {
         return this.disposed;
@@ -243,7 +243,7 @@ class DeviceCommands {
         return this._filterCommonTypes(resp);
     }
     _filterCommonTypes(res) {
-        this._cancelableRequestBySend = false;
+        this.device.clearCancelableAction();
         if (res.type === 'Failure') {
             const { code } = res.message;
             let { message } = res.message;
@@ -259,7 +259,7 @@ class DeviceCommands {
             return Promise.resolve(res);
         }
         if (res.type === 'ButtonRequest') {
-            this._cancelableRequestBySend = true;
+            this.device.setCancelableAction(() => this.cancelWithFallback());
             if (res.message.code === 'ButtonRequest_PassphraseEntry') {
                 this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
             }
@@ -274,25 +274,22 @@ class DeviceCommands {
             });
         }
         if (res.type === 'PinMatrixRequest') {
-            return this._promptPin(res.message.type).then(pin => this._commonCall('PinMatrixAck', { pin }).then(response => {
+            return (0, prompts_1.promptPin)(this.device, res.message.type).then(pin => this._commonCall('PinMatrixAck', { pin }).then(response => {
                 if (!this.device.features.unlocked) {
                     return this.device.getFeatures().then(() => response);
                 }
                 return response;
-            }), () => this._commonCall('Cancel', {}));
+            }), error => Promise.reject(error));
         }
         if (res.type === 'PassphraseRequest') {
-            return this._promptPassphrase().then(response => {
-                const { passphrase, passphraseOnDevice } = response;
+            return (0, prompts_1.promptPassphrase)(this.device).then(({ value, passphraseOnDevice }) => {
                 return !passphraseOnDevice
-                    ? this._commonCall('PassphraseAck', { passphrase })
+                    ? this._commonCall('PassphraseAck', { passphrase: value.normalize('NFKD') })
                     : this._commonCall('PassphraseAck', { on_device: true });
-            }, err => this._commonCall('Cancel', {}).catch((e) => {
-                throw err || e;
-            }));
+            }, error => Promise.reject(error));
         }
         if (res.type === 'WordRequest') {
-            return this._promptWord(res.message.type).then(word => this._commonCall('WordAck', { word }), () => this._commonCall('Cancel', {}));
+            return (0, prompts_1.promptWord)(this.device, res.message.type).then(word => this._commonCall('WordAck', { word }), error => Promise.reject(error));
         }
         return Promise.resolve(res);
     }
@@ -304,60 +301,6 @@ class DeviceCommands {
         });
         return message.address;
     }
-    _promptPin(type) {
-        return new Promise((resolve, reject) => {
-            if (this.device.listenerCount(events_1.DEVICE.PIN) > 0) {
-                this._cancelableRequest = reject;
-                this.device.emit(events_1.DEVICE.PIN, this.device, type, (err, pin) => {
-                    this._cancelableRequest = undefined;
-                    if (err || pin == null) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(pin);
-                    }
-                });
-            }
-            else {
-                console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
-                reject(constants_1.ERRORS.TypedError('Runtime', '_promptPin: PIN callback not configured'));
-            }
-        });
-    }
-    _promptPassphrase() {
-        return new Promise((resolve, reject) => {
-            if (this.device.listenerCount(events_1.DEVICE.PASSPHRASE) > 0) {
-                this._cancelableRequest = reject;
-                this.device.emit(events_1.DEVICE.PASSPHRASE, this.device, (response, error) => {
-                    this._cancelableRequest = undefined;
-                    if (error) {
-                        reject(error);
-                    }
-                    else {
-                        resolve(response);
-                    }
-                });
-            }
-            else {
-                console.warn('[DeviceCommands] [call] Passphrase callback not configured, cancelling request');
-                reject(constants_1.ERRORS.TypedError('Runtime', '_promptPassphrase: Passphrase callback not configured'));
-            }
-        });
-    }
-    _promptWord(type) {
-        return new Promise((resolve, reject) => {
-            this._cancelableRequest = reject;
-            this.device.emit(events_1.DEVICE.WORD, this.device, type, (err, word) => {
-                this._cancelableRequest = undefined;
-                if (err || word == null) {
-                    reject(err);
-                }
-                else {
-                    resolve(word.toLocaleLowerCase());
-                }
-            });
-        });
-    }
     async getAccountDescriptor(coinInfo, indexOrPath, derivationType) {
         const address_n = Array.isArray(indexOrPath)
             ? indexOrPath
@@ -410,40 +353,32 @@ class DeviceCommands {
         }
         throw constants_1.ERRORS.TypedError('Runtime', 'DeviceCommands.getAccountDescriptor: unsupported coinInfo.type');
     }
-    async cancel() {
-        if (this._cancelableRequest) {
-            this._cancelableRequest();
-            this._cancelableRequest = undefined;
-            return;
-        }
-        if (this.disposed) {
-            return;
-        }
-        this.dispose();
-        if (!this._cancelableRequestBySend) {
-            if (this.callPromise) {
-                await this.callPromise;
-            }
-            return;
-        }
+    async cancelWithFallback() {
         const { name, version } = this.transport;
         if (name === 'BridgeTransport' && !utils_1.versionUtils.isNewer(version, '2.0.28')) {
             try {
-                await this.device.legacyForceRelease();
+                await (0, utils_1.createTimeoutPromise)(1);
+                await this.device.acquire();
+                await (0, prompts_1.cancelPrompt)(this.device, false);
             }
             catch (err) {
             }
         }
         else {
-            await this.transport.send({
-                protocol: this.device.protocol,
-                session: this.transportSession,
-                name: 'Cancel',
-                data: {},
-            });
-            if (this.callPromise) {
+            return (0, prompts_1.cancelPrompt)(this.device, false);
+        }
+    }
+    async cancel() {
+        if (this.disposed) {
+            return;
+        }
+        this.dispose();
+        if (this.callPromise) {
+            try {
                 await this.callPromise;
             }
+            catch {
+            }
         }
     }
 }

package/lib/device/DeviceList.d.ts

@@ -25,7 +25,7 @@ export interface IDeviceList {
     dispose: DeviceList['dispose'];
 }
 export declare const assertDeviceListConnected: (deviceList: IDeviceList) => asserts deviceList is DeviceList;
-type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug'> & {
+type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | '_sessionsBackgroundUrl'> & {
     messages: Record<string, any>;
 };
 type InitParams = Pick<ConnectSettings, 'pendingTransportEvent' | 'transportReconnect'>;
@@ -34,16 +34,19 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
     private transports;
     private devices;
     private creatingDevicesDescriptors;
+    private createDevicesQueue;
     private readonly authPenaltyManager;
     private initPromise?;
     private rejectPending?;
     private transportCommonArgs;
     isConnected(): this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
-    constructor({ messages, priority, debug }: ConstructorParams);
+    constructor({ messages, priority, debug, _sessionsBackgroundUrl }: ConstructorParams);
     private createTransport;
     setTransports(transports: ConnectSettings['transports']): void;
     private onTransportUpdate;
+    private waitForCreateDevicesQueue;
+    private removeFromCreateDevicesQueue;
     init(initParams?: InitParams): Promise<void>;
     private createInitPromise;
     private createReconnectPromise;

package/lib/device/DeviceList.js

@@ -42,17 +42,17 @@ class DeviceList extends utils_1.TypedEmitter {
     pendingConnection() {
         return this.initPromise;
     }
-    constructor({ messages, priority, debug }) {
+    constructor({ messages, priority, debug, _sessionsBackgroundUrl }) {
         super();
         this.devices = {};
         this.creatingDevicesDescriptors = {};
+        this.createDevicesQueue = [];
         const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
-        const abortController = new AbortController();
         this.authPenaltyManager = createAuthPenaltyManager(priority);
         this.transportCommonArgs = {
             messages,
             logger: transportLogger,
-            signal: abortController.signal,
+            sessionsBackgroundUrl: _sessionsBackgroundUrl,
         };
         this.transports = [
             new transport_1.BridgeTransport({
@@ -104,6 +104,7 @@ class DeviceList extends utils_1.TypedEmitter {
             this.creatingDevicesDescriptors[path] = descriptor;
             switch (category.type) {
                 case 'disconnected':
+                    this.removeFromCreateDevicesQueue(path);
                     if (!device)
                         break;
                     device.disconnect();
@@ -111,6 +112,9 @@ class DeviceList extends utils_1.TypedEmitter {
                     this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
                     break;
                 case 'connected':
+                    if (!(await this.waitForCreateDevicesQueue(path))) {
+                        break;
+                    }
                     const penalty = this.authPenaltyManager.get();
                     if (penalty) {
                         await (0, promiseUtils_1.resolveAfter)(501 + penalty, null).promise;
@@ -123,14 +127,18 @@ class DeviceList extends utils_1.TypedEmitter {
                         this.devices[path] = device;
                         this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
                     }
+                    this.removeFromCreateDevicesQueue(path);
                     break;
                 case 'acquired':
-                    if (!device)
-                        break;
                     if (category.subtype === 'elsewhere') {
-                        device.featuresNeedsReload = true;
-                        device.interruptionFromOutside();
+                        this.removeFromCreateDevicesQueue(path);
+                        if (device) {
+                            device.featuresNeedsReload = true;
+                            device.interruptionFromOutside();
+                        }
                     }
+                    if (!device)
+                        break;
                     _log.debug('Event', events_1.DEVICE.CHANGED, device.toMessageObject());
                     this.emit(events_1.DEVICE.CHANGED, device.toMessageObject());
                     _log.debug('Event', events_1.DEVICE.ACQUIRED, device.toMessageObject());
@@ -159,6 +167,20 @@ class DeviceList extends utils_1.TypedEmitter {
             device === null || device === void 0 ? void 0 : device.updateDescriptor(descriptor);
         });
     }
+    async waitForCreateDevicesQueue(path) {
+        const dfd = (0, utils_1.createDeferred)(path);
+        const prevQueue = this.createDevicesQueue.slice();
+        this.createDevicesQueue.push(dfd);
+        await (0, utils_1.promiseAllSequence)(prevQueue.map(pr => () => pr.promise));
+        return this.createDevicesQueue.includes(dfd);
+    }
+    removeFromCreateDevicesQueue(path) {
+        const index = this.createDevicesQueue.findIndex(dfd => dfd.id === path);
+        if (index >= 0) {
+            const [dfd] = this.createDevicesQueue.splice(index, 1);
+            dfd.resolve();
+        }
+    }
     init(initParams = {}) {
         if (!this.initPromise) {
             _log.debug('Initializing transports');
@@ -210,12 +232,12 @@ class DeviceList extends utils_1.TypedEmitter {
             throw new Error(enumerateResult.error);
         }
         const descriptors = enumerateResult.payload;
+        const waitForDevicesPromise = initParams.pendingTransportEvent && descriptors.length
+            ? this.waitForDevices(descriptors.length, 10000)
+            : Promise.resolve();
         transport.handleDescriptorsChange(descriptors);
         transport.listen();
-        const awaitedDevices = descriptors.length - Object.keys(this.devices).length;
-        if (awaitedDevices > 0 && initParams.pendingTransportEvent) {
-            await this.waitForDevices(awaitedDevices, 10000);
-        }
+        await waitForDevicesPromise;
         return transport;
     }
     waitForDevices(deviceCount, autoResolveMs) {
@@ -294,6 +316,8 @@ class DeviceList extends utils_1.TypedEmitter {
         devices.forEach(device => {
             this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
         });
+        this.createDevicesQueue.forEach(dfd => dfd.resolve());
+        this.createDevicesQueue = [];
         await Promise.all(devices.map(device => device.dispose()));
         transport === null || transport === void 0 ? void 0 : transport.stop();
     }