@trezor/connect 9.0.10 → 9.1.1

package/lib/data/coinInfo.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllNetworks = exports.getUniqueNetworks = exports.parseCoinsJson = exports.getCoinName = exports.getCoinInfo = exports.getCoinInfoByHash = exports.fixCoinInfoNetwork = exports.getBech32Network = exports.getSegwitNetwork = exports.getMiscNetwork = exports.getEthereumNetwork = exports.getBitcoinNetwork = exports.cloneCoinInfo = void 0;
+exports.getAllNetworks = exports.getUniqueNetworks = exports.parseCoinsJson = exports.getCoinName = exports.getCoinInfo = exports.getCoinInfoByHash = exports.fixCoinInfoNetwork = exports.getBech32Network = exports.getSegwitNetwork = exports.getMiscNetwork = exports.getEthereumNetwork = exports.getBitcoinNetwork = void 0;
 const constants_1 = require("../constants");
 const pathUtils_1 = require("../utils/pathUtils");
+const utils_1 = require("@trezor/utils");
 const bitcoinNetworks = [];
 const ethereumNetworks = [];
 const miscNetworks = [];
-function cloneCoinInfo(info) {
-    const jsonString = JSON.stringify(info);
-    if (jsonString === undefined) {
-        return info;
-    }
-    return JSON.parse(jsonString);
-}
-exports.cloneCoinInfo = cloneCoinInfo;
 const getBitcoinNetwork = (pathOrName) => {
-    const networks = cloneCoinInfo(bitcoinNetworks);
+    const networks = (0, utils_1.cloneObject)(bitcoinNetworks);
     if (typeof pathOrName === 'string') {
         const name = pathOrName.toLowerCase();
         return networks.find(n => n.name.toLowerCase() === name ||
@@ -27,7 +20,7 @@ const getBitcoinNetwork = (pathOrName) => {
 };
 exports.getBitcoinNetwork = getBitcoinNetwork;
 const getEthereumNetwork = (pathOrName) => {
-    const networks = cloneCoinInfo(ethereumNetworks);
+    const networks = (0, utils_1.cloneObject)(ethereumNetworks);
     if (typeof pathOrName === 'string') {
         const name = pathOrName.toLowerCase();
         return networks.find(n => n.name.toLowerCase() === name || n.shortcut.toLowerCase() === name);
@@ -37,7 +30,7 @@ const getEthereumNetwork = (pathOrName) => {
 };
 exports.getEthereumNetwork = getEthereumNetwork;
 const getMiscNetwork = (pathOrName) => {
-    const networks = cloneCoinInfo(miscNetworks);
+    const networks = (0, utils_1.cloneObject)(miscNetworks);
     if (typeof pathOrName === 'string') {
         const name = pathOrName.toLowerCase();
         return networks.find(n => n.name.toLowerCase() === name || n.shortcut.toLowerCase() === name);
@@ -73,7 +66,7 @@ const getBech32Network = (coin) => {
 };
 exports.getBech32Network = getBech32Network;
 const fixCoinInfoNetwork = (ci, path) => {
-    const coinInfo = cloneCoinInfo(ci);
+    const coinInfo = (0, utils_1.cloneObject)(ci);
     if (path[0] === (0, pathUtils_1.toHardened)(84)) {
         const bech32Network = (0, exports.getBech32Network)(coinInfo);
         if (bech32Network) {
@@ -108,7 +101,7 @@ const detectBtcVersion = (data) => {
     return 'btc';
 };
 const getCoinInfoByHash = (hash, networkInfo) => {
-    const networks = cloneCoinInfo(bitcoinNetworks);
+    const networks = (0, utils_1.cloneObject)(bitcoinNetworks);
     const result = networks.find(info => hash.toLowerCase() === info.hashGenesisBlock.toLowerCase());
     if (!result) {
         throw constants_1.ERRORS.TypedError('Method_UnknownCoin', `Coin info not found for hash: ${hash} ${networkInfo.hashGenesisBlock}`);

package/lib/data/config.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.config = void 0;
 const constants_1 = require("@trezor/transport/lib/constants");
 exports.config = {
-    webusb: constants_1.TREZOR_DESCS,
+    webusb: constants_1.TREZOR_USB_DESCRIPTORS,
     whitelist: [
         { origin: 'chrome-extension://imloifkgjagghnncjkhggdhalmcnfklk', priority: 1 },
         { origin: 'chrome-extension://niebkpllfhmpfbffbfifagfgoamhpflf', priority: 1 },
@@ -184,6 +184,7 @@ exports.config = {
             capabilities: ['coinjoin'],
             methods: [
                 'authorizeCoinjoin',
+                'cancelCoinjoinAuthorization',
                 'getOwnershipId',
                 'getOwnershipProof',
                 'setBusy',
@@ -191,6 +192,11 @@ exports.config = {
             ],
             min: ['1.12.1', '2.5.3'],
         },
+        {
+            methods: ['showDeviceTutorial'],
+            min: ['0', '2.6.1'],
+            comment: ['Only on T2B1'],
+        },
     ],
 };
 //# sourceMappingURL=config.js.map

package/lib/data/version.d.ts

@@ -1,3 +1,3 @@
-export declare const VERSION = "9.0.10";
+export declare const VERSION = "9.1.1";
 export declare const DEFAULT_DOMAIN: string;
 //# sourceMappingURL=version.d.ts.map

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.0.10';
+exports.VERSION = '9.1.1';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 exports.DEFAULT_DOMAIN = `https://connect.trezor.io/${versionN[0]}/`;
 //# sourceMappingURL=version.js.map

package/lib/device/Device.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
+import { TypedEmitter } from '@trezor/utils/lib/typedEventEmitter';
 import { DeviceCommands } from './DeviceCommands';
 import { PROTO, NETWORK } from '../constants';
 import { DEVICE, DeviceButtonRequestPayload } from '../events';
 import { Deferred } from '../utils/deferred';
-import type { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
+import type { Transport, Descriptor } from '@trezor/transport';
 import type { Device as DeviceTyped, DeviceFirmwareStatus, Features, ReleaseInfo, UnavailableCapabilities } from '../types';
 export type RunOptions = {
     skipFinalReload?: boolean;
@@ -16,29 +15,23 @@ export type RunOptions = {
     useCardanoDerivation?: boolean;
 };
 export interface DeviceEvents {
-    [DEVICE.PIN]: [Device, PROTO.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
-    [DEVICE.WORD]: [Device, PROTO.WordRequestType, (err: any, word: string) => void];
-    [DEVICE.PASSPHRASE]: [Device, (response: any) => void];
-    [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
-    [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
-    [DEVICE.ACQUIRED]: [];
+    [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: any) => void) => void;
+    [DEVICE.PASSPHRASE_ON_DEVICE]: () => void;
+    [DEVICE.BUTTON]: (device: Device, payload: DeviceButtonRequestPayload) => void;
+    [DEVICE.ACQUIRED]: () => void;
 }
-export interface Device {
-    on<K extends keyof DeviceEvents>(type: K, listener: (...event: DeviceEvents[K]) => void): this;
-    off<K extends keyof DeviceEvents>(type: K, listener: (...event: DeviceEvents[K]) => void): this;
-    emit<K extends keyof DeviceEvents>(type: K, ...args: DeviceEvents[K]): boolean;
-}
-export declare class Device extends EventEmitter {
+export declare class Device extends TypedEmitter<DeviceEvents> {
     transport: Transport;
-    originalDescriptor: DeviceDescriptor;
+    originalDescriptor: Descriptor;
     unreadableError?: string;
     firmwareStatus: DeviceFirmwareStatus;
     firmwareRelease?: ReleaseInfo | null;
     features: Features;
     featuresNeedsReload: boolean;
-    deferredActions: {
-        [key: string]: Deferred<void>;
-    };
+    acquirePromise?: ReturnType<Transport['acquire']>;
+    releasePromise?: ReturnType<Transport['release']>;
     runPromise?: Deferred<void> | null;
     loaded: boolean;
     inconsistent: boolean;
@@ -52,9 +45,9 @@ export declare class Device extends EventEmitter {
     unavailableCapabilities: UnavailableCapabilities;
     networkTypeState: NETWORK.NetworkType[];
     firmwareType: 'regular' | 'bitcoin-only';
-    constructor(transport: Transport, descriptor: DeviceDescriptor);
-    static fromDescriptor(transport: Transport, originalDescriptor: DeviceDescriptor): Device;
-    static createUnacquired(transport: Transport, descriptor: DeviceDescriptor, unreadableError?: string): Device;
+    constructor(transport: Transport, descriptor: Descriptor);
+    static fromDescriptor(transport: Transport, originalDescriptor: Descriptor): Device;
+    static createUnacquired(transport: Transport, descriptor: Descriptor, unreadableError?: string): Device;
     acquire(): Promise<void>;
     release(): Promise<void>;
     cleanup(): Promise<void>;
@@ -76,7 +69,6 @@ export declare class Device extends EventEmitter {
     getFeatures(): Promise<void>;
     _updateFeatures(feat: Features): void;
     isUnacquired(): boolean;
-    updateDescriptor(upcomingDescriptor: DeviceDescriptor): Promise<void>;
     disconnect(): void;
     isBootloader(): boolean;
     isInitialized(): boolean;
@@ -93,7 +85,7 @@ export declare class Device extends EventEmitter {
     getDevicePath(): string;
     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;
-    dispose(): Promise<void> | undefined;
+    dispose(): import("packages/transport/lib/types").AbortableCall<void, "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" | "session not found"> | undefined;
     getMode(): "normal" | "bootloader" | "initialize" | "seedless";
     toMessageObject(): DeviceTyped;
     _getNetworkTypeState(): "bitcoin" | "ethereum" | "nem" | "eos" | "stellar" | "cardano" | "ripple" | "tezos" | "binance";

package/lib/device/Device.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
-const tslib_1 = require("tslib");
-const events_1 = tslib_1.__importDefault(require("events"));
+const typedEventEmitter_1 = require("@trezor/utils/lib/typedEventEmitter");
 const DeviceCommands_1 = require("./DeviceCommands");
 const constants_1 = require("../constants");
-const events_2 = require("../events");
+const events_1 = require("../events");
 const coinInfo_1 = require("../data/coinInfo");
 const firmwareInfo_1 = require("../data/firmwareInfo");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
@@ -18,11 +17,12 @@ const parseRunOptions = (options) => {
         options = {};
     return options;
 };
-class Device extends events_1.default {
+class Device extends typedEventEmitter_1.TypedEmitter {
     constructor(transport, descriptor) {
         super();
         this.featuresNeedsReload = false;
-        this.deferredActions = {};
+        this.acquirePromise = undefined;
+        this.releasePromise = undefined;
         this.loaded = false;
         this.inconsistent = false;
         this.keepSession = false;
@@ -53,54 +53,53 @@ class Device extends events_1.default {
         return device;
     }
     async acquire() {
-        this.deferredActions[events_2.DEVICE.ACQUIRE] = (0, deferred_1.create)();
-        this.deferredActions[events_2.DEVICE.ACQUIRED] = (0, deferred_1.create)();
-        try {
-            const sessionID = await this.transport.acquire({
+        this.acquirePromise = this.transport.acquire({
+            input: {
                 path: this.originalDescriptor.path,
                 previous: this.originalDescriptor.session,
-            }, false);
-            _log.debug('Expected session id:', sessionID);
-            this.activitySessionID = sessionID;
-            this.deferredActions[events_2.DEVICE.ACQUIRED].resolve();
-            delete this.deferredActions[events_2.DEVICE.ACQUIRED];
-            if (this.commands) {
-                this.commands.dispose();
-            }
-            this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, sessionID);
-            this.deferredActions[events_2.DEVICE.RELEASE] = (0, deferred_1.create)();
-        }
-        catch (error) {
-            this.deferredActions[events_2.DEVICE.ACQUIRED].resolve();
-            delete this.deferredActions[events_2.DEVICE.ACQUIRED];
+            },
+        });
+        const acquireResult = await this.acquirePromise.promise;
+        this.acquirePromise = undefined;
+        if (!acquireResult.success) {
             if (this.runPromise) {
-                this.runPromise.reject(error);
-            }
-            else {
-                throw error;
+                this.runPromise.reject(new Error(acquireResult.error));
+                this.runPromise = null;
             }
-            this.runPromise = null;
+            throw acquireResult.error;
+        }
+        const sessionID = acquireResult.payload;
+        _log.debug('Expected session id:', sessionID);
+        this.activitySessionID = sessionID;
+        this.originalDescriptor.session = sessionID;
+        if (this.commands) {
+            this.commands.dispose();
         }
+        this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, sessionID);
     }
     async release() {
-        if (this.isUsedHere() && !this.keepSession && this.activitySessionID) {
+        if (this.isUsedHere() &&
+            !this.keepSession &&
+            this.activitySessionID &&
+            !this.releasePromise) {
             if (this.commands) {
                 this.commands.dispose();
                 if (this.commands.callPromise) {
-                    try {
-                        await this.commands.callPromise;
-                    }
-                    catch (error) {
-                        this.commands.callPromise = undefined;
-                    }
+                    await this.commands.callPromise.promise;
                 }
             }
-            try {
-                await this.transport.release(this.activitySessionID, false, false);
-                if (this.deferredActions[events_2.DEVICE.RELEASE])
-                    await this.deferredActions[events_2.DEVICE.RELEASE].promise;
+            if (this.releasePromise) {
+                await this.releasePromise;
             }
-            catch (err) {
+            this.releasePromise = this.transport.release({
+                session: this.activitySessionID,
+                path: this.originalDescriptor.path,
+            });
+            const releaseResponse = await this.releasePromise.promise;
+            this.releasePromise = undefined;
+            if (releaseResponse.success) {
+                this.activitySessionID = null;
+                this.originalDescriptor.session = null;
             }
         }
     }
@@ -119,26 +118,25 @@ class Device extends events_1.default {
         return this.runPromise.promise;
     }
     async override(error) {
-        if (this.deferredActions[events_2.DEVICE.ACQUIRE]) {
-            await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
+        if (this.acquirePromise) {
+            await this.acquirePromise.promise;
         }
         if (this.runPromise) {
             await this.interruptionFromUser(error);
         }
-        if (!this.keepSession && this.deferredActions[events_2.DEVICE.RELEASE]) {
-            await this.deferredActions[events_2.DEVICE.RELEASE].promise;
+        if (this.releasePromise) {
+            await this.releasePromise.promise;
         }
     }
     async interruptionFromUser(error) {
         _log.debug('interruptionFromUser');
-        if (this.commands) {
-            await this.commands.cancel();
-            this.commands.dispose();
-        }
         if (this.runPromise) {
             this.runPromise.reject(error);
             this.runPromise = null;
         }
+        if (this.commands) {
+            await this.commands.cancel();
+        }
     }
     interruptionFromOutside() {
         _log.debug('interruptionFromOutside');
@@ -149,9 +147,13 @@ class Device extends events_1.default {
             this.runPromise.reject(constants_1.ERRORS.TypedError('Device_UsedElsewhere'));
             this.runPromise = null;
         }
+        this.transport.releaseDevice(this.originalDescriptor.path);
     }
     async _runInner(fn, options) {
         var _a;
+        if (this.releasePromise) {
+            await this.releasePromise.promise;
+        }
         if (!this.isUsedHere() || ((_a = this.commands) === null || _a === void 0 ? void 0 : _a.disposed) || !this.getExternalState()) {
             await this.acquire();
             try {
@@ -171,15 +173,16 @@ class Device extends events_1.default {
                     return this._runInner(() => Promise.resolve({}), options);
                 }
                 this.inconsistent = true;
-                await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
                 this.runPromise = null;
-                return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}, code: ${error.code}`));
+                return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message} ${error.code ? `, code: ${error.code}` : ''}`));
             }
         }
         if (options.keepSession) {
             this.keepSession = true;
         }
-        await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
+        if (this.listeners(events_1.DEVICE.ACQUIRED).length > 0) {
+            this.emit(events_1.DEVICE.ACQUIRED);
+        }
         if (fn) {
             await fn();
         }
@@ -316,6 +319,9 @@ class Device extends events_1.default {
         if (!feat.model && feat.major_version === 1) {
             feat.model = '1';
         }
+        if (!feat.internal_model) {
+            feat.internal_model = (0, deviceFeaturesUtils_1.ensureInternalModelFeature)(feat.model);
+        }
         this.features = feat;
         this.featuresNeedsReload = false;
         this.firmwareType =
@@ -328,55 +334,9 @@ class Device extends events_1.default {
     isUnacquired() {
         return this.features === undefined;
     }
-    async updateDescriptor(upcomingDescriptor) {
-        const originalSession = this.originalDescriptor.session;
-        const upcomingSession = upcomingDescriptor.session;
-        _log.debug('updateDescriptor', 'currentSession', originalSession, 'upcoming', upcomingSession, 'lastUsedID', this.activitySessionID);
-        if (!originalSession && !upcomingSession && !this.activitySessionID) {
-            return;
-        }
-        if (this.deferredActions[events_2.DEVICE.ACQUIRED]) {
-            await this.deferredActions[events_2.DEVICE.ACQUIRED].promise;
-        }
-        if (!upcomingSession) {
-            if (this.listeners(events_2.DEVICE.ACQUIRED).length > 0) {
-                this.emit(events_2.DEVICE.ACQUIRED);
-            }
-        }
-        const methodStillRunning = this.commands && !this.commands.disposed;
-        if (!upcomingSession && !methodStillRunning) {
-            if (originalSession === this.activitySessionID) {
-                _log.debug('Session released by this app');
-                if (this.deferredActions[events_2.DEVICE.RELEASE]) {
-                    this.deferredActions[events_2.DEVICE.RELEASE].resolve();
-                    delete this.deferredActions[events_2.DEVICE.RELEASE];
-                }
-                this.activitySessionID = null;
-            }
-            else {
-                _log.debug('Session released by other app');
-                this.featuresNeedsReload = true;
-            }
-            this.keepSession = false;
-        }
-        else if (upcomingSession === this.activitySessionID) {
-            _log.debug('Session acquired by this app');
-            if (this.deferredActions[events_2.DEVICE.ACQUIRE]) {
-                this.deferredActions[events_2.DEVICE.ACQUIRE].resolve();
-            }
-        }
-        else {
-            _log.debug('Session acquired by other app');
-            this.interruptionFromOutside();
-        }
-        this.originalDescriptor = upcomingDescriptor;
-    }
     disconnect() {
         _log.debug('Disconnect cleanup');
-        if (this.deferredActions[events_2.DEVICE.RELEASE]) {
-            this.deferredActions[events_2.DEVICE.RELEASE].resolve();
-            delete this.deferredActions[events_2.DEVICE.RELEASE];
-        }
+        this.activitySessionID = null;
         this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
         this.runPromise = null;
     }
@@ -433,17 +393,17 @@ class Device extends events_1.default {
     }
     hasUnexpectedMode(allow, require) {
         if (this.features) {
-            if (this.isBootloader() && !allow.includes(events_2.UI.BOOTLOADER)) {
-                return events_2.UI.BOOTLOADER;
+            if (this.isBootloader() && !allow.includes(events_1.UI.BOOTLOADER)) {
+                return events_1.UI.BOOTLOADER;
             }
-            if (!this.isInitialized() && !allow.includes(events_2.UI.INITIALIZE)) {
-                return events_2.UI.INITIALIZE;
+            if (!this.isInitialized() && !allow.includes(events_1.UI.INITIALIZE)) {
+                return events_1.UI.INITIALIZE;
             }
-            if (this.isSeedless() && !allow.includes(events_2.UI.SEEDLESS)) {
-                return events_2.UI.SEEDLESS;
+            if (this.isSeedless() && !allow.includes(events_1.UI.SEEDLESS)) {
+                return events_1.UI.SEEDLESS;
             }
-            if (!this.isBootloader() && require.includes(events_2.UI.BOOTLOADER)) {
-                return events_2.UI.NOT_IN_BOOTLOADER;
+            if (!this.isBootloader() && require.includes(events_1.UI.BOOTLOADER)) {
+                return events_1.UI.NOT_IN_BOOTLOADER;
             }
         }
         return null;
@@ -455,7 +415,11 @@ class Device extends events_1.default {
                 if (this.commands) {
                     this.commands.cancel();
                 }
-                return this.transport.release(this.activitySessionID, true);
+                return this.transport.release({
+                    session: this.activitySessionID,
+                    path: this.originalDescriptor.path,
+                    onClose: true,
+                });
             }
             catch (err) {
             }

package/lib/device/DeviceCommands.d.ts

@@ -11,7 +11,7 @@ export type TypedResponseMessage<T extends MessageKey> = {
 type TypedCallResponseMap = {
     [K in keyof MessageType]: TypedResponseMessage<K>;
 };
-export type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
+type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
 export type PassphrasePromptResponse = {
     passphrase?: string;
     passphraseOnDevice?: boolean;
@@ -22,8 +22,9 @@ export declare class DeviceCommands {
     transport: Transport;
     sessionId: string;
     disposed: boolean;
-    callPromise?: Promise<DefaultMessageResponse>;
+    callPromise?: ReturnType<Transport['call']>;
     _cancelableRequest?: (error?: any) => void;
+    _cancelableRequestBySend?: boolean;
     constructor(device: Device, transport: Transport, sessionId: string);
     dispose(): void;
     isDisposed(): boolean;
@@ -48,7 +49,7 @@ export declare class DeviceCommands {
     ethereumGetPublicKey({ address_n, show_display, }: Messages.EthereumGetPublicKey): Promise<HDNodeResponse>;
     preauthorize(throwError: boolean): Promise<boolean>;
     getDeviceState(networkType?: string): Promise<string>;
-    call(type: MessageKey, msg?: DefaultMessageResponse['message']): Promise<DefaultMessageResponse>;
+    private call;
     typedCall<T extends MessageKey, R extends MessageKey[]>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedCallResponseMap[R[number]]>;
     typedCall<T extends MessageKey, R extends MessageKey>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedResponseMessage<R>>;
     _commonCall(type: MessageKey, msg?: DefaultMessageResponse['message']): Promise<DefaultMessageResponse>;

package/lib/device/DeviceCommands.js

@@ -240,20 +240,20 @@ class DeviceCommands {
         return this._getAddressForNetworkType();
     }
     async call(type, msg = {}) {
-        const logMessage = filterForLog(type, msg);
-        logger.debug('Sending', type, logMessage);
-        try {
-            const promise = this.transport.call(this.sessionId, type, msg, false);
-            this.callPromise = promise;
-            const res = await promise;
-            const logMessage = filterForLog(res.type, res.message);
-            logger.debug('Received', res.type, logMessage);
-            return res;
-        }
-        catch (error) {
-            logger.warn('Received error', error);
-            throw error;
-        }
+        logger.debug('Sending', type, filterForLog(type, msg));
+        this.callPromise = this.transport.call({
+            session: this.sessionId,
+            name: type,
+            data: msg,
+        });
+        const res = await this.callPromise.promise;
+        this.callPromise = undefined;
+        if (!res.success) {
+            logger.warn('Received error', res.error);
+            throw new Error(res.error);
+        }
+        logger.debug('Received', res.payload.type, filterForLog(res.payload.type, res.payload.message));
+        return res.payload;
     }
     async typedCall(type, resType, msg) {
         if (this.disposed) {
@@ -264,16 +264,20 @@ class DeviceCommands {
             assertType(response, resType);
         }
         catch (error) {
-            await this.transport.read(this.sessionId, false);
+            await this.transport.receive({ session: this.sessionId });
             throw error;
         }
         return response;
     }
     async _commonCall(type, msg) {
         const resp = await this.call(type, msg);
+        if (this.disposed) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
+        }
         return this._filterCommonTypes(resp);
     }
     _filterCommonTypes(res) {
+        this._cancelableRequestBySend = false;
         if (res.type === 'Failure') {
             const { code } = res.message;
             let { message } = res.message;
@@ -289,11 +293,12 @@ class DeviceCommands {
             return Promise.resolve(res);
         }
         if (res.type === 'ButtonRequest') {
+            this._cancelableRequestBySend = true;
             if (res.message.code === '_Deprecated_ButtonRequest_PassphraseType') {
                 res.message.code = 'ButtonRequest_PassphraseType';
             }
             if (res.message.code === 'ButtonRequest_PassphraseEntry') {
-                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE, this.device);
+                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
             }
             else {
                 this.device.emit(events_1.DEVICE.BUTTON, this.device, res.message);
@@ -316,7 +321,7 @@ class DeviceCommands {
                 return this._commonCall('PassphraseAck', { passphrase: state });
             }
             if (legacy && res.message._on_device) {
-                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE, this.device);
+                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
                 return this._commonCall('PassphraseAck', { _state: state });
             }
             return this._promptPassphrase().then(response => {
@@ -475,13 +480,30 @@ class DeviceCommands {
         if (this.disposed) {
             return;
         }
+        this.dispose();
+        if (!this._cancelableRequestBySend) {
+            if (this.callPromise) {
+                await this.callPromise.promise;
+            }
+            return;
+        }
         const { name, version } = this.transport;
         if (name === 'BridgeTransport' && (0, versionUtils_1.versionCompare)(version, '2.0.28') < 1) {
-            await this.device.legacyForceRelease();
+            try {
+                await this.device.legacyForceRelease();
+            }
+            catch (err) {
+            }
         }
         else {
-            await this.transport.post(this.sessionId, 'Cancel', {}, false).catch(() => { });
-            await this.transport.read(this.sessionId, false).catch(() => { });
+            await this.transport.send({
+                session: this.sessionId,
+                name: 'Cancel',
+                data: {},
+            }).promise;
+            if (this.callPromise) {
+                await this.callPromise.promise;
+            }
         }
     }
 }