@trezor/connect 9.4.7-beta.1 → 9.4.8-beta.1

package/lib/device/Device.d.ts

@@ -1,20 +1,19 @@
-import { TypedEmitter } from '@trezor/utils';
-import { Session } from '@trezor/transport';
 import { TransportProtocol } from '@trezor/protocol';
-import { type Transport, type Descriptor } from '@trezor/transport';
+import { Session } from '@trezor/transport';
+import { type Descriptor, type Transport } from '@trezor/transport';
+import { TypedEmitter } from '@trezor/utils';
 import { DeviceCommands } from './DeviceCommands';
 import { PROTO } from '../constants';
-import { DEVICE, DeviceButtonRequestPayload, UiResponsePin, UiResponsePassphrase, UiResponseWord } from '../events';
-import { Device as DeviceTyped, DeviceFirmwareStatus, DeviceState, ReleaseInfo, UnavailableCapabilities, FirmwareType, VersionArray, DeviceUniquePath } from '../types';
 import { IStateStorage } from './StateStorage';
 import type { PromptCallback } from './prompts';
-export type RunOptions = {
+import { DEVICE, DeviceButtonRequestPayload, DeviceVersionChanged, UiResponsePassphrase, UiResponsePin, UiResponseWord } from '../events';
+import { DeviceFirmwareStatus, DeviceState, Device as DeviceTyped, DeviceUniquePath, FirmwareType, ReleaseInfo, UnavailableCapabilities, VersionArray } from '../types';
+type RunOptions = {
     skipFinalReload?: boolean;
-    waiting?: boolean;
-    onlyOneActivity?: boolean;
-    cancelPopupRequest?: () => any;
     keepSession?: boolean;
     useCardanoDerivation?: boolean;
+    skipFirmwareChecks?: boolean;
+    skipLanguageChecks?: boolean;
 };
 export declare const GET_FEATURES_TIMEOUT = 3000;
 export declare const GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
@@ -24,6 +23,7 @@ export interface DeviceEvents {
     [DEVICE.PASSPHRASE]: (device: Device, callback: PromptCallback<UiResponsePassphrase['payload']>) => void;
     [DEVICE.PASSPHRASE_ON_DEVICE]: () => void;
     [DEVICE.BUTTON]: (device: Device, payload: DeviceButtonRequestPayload) => void;
+    [DEVICE.FIRMWARE_VERSION_CHANGED]: (payload: DeviceVersionChanged['payload']) => void;
 }
 type DeviceLifecycle = typeof DEVICE.CONNECT | typeof DEVICE.CONNECT_UNACQUIRED | typeof DEVICE.DISCONNECT | typeof DEVICE.CHANGED;
 type DeviceLifecycleListener = (lifecycle: DeviceLifecycle) => void;
@@ -36,7 +36,7 @@ type DeviceParams = {
 export declare class Device extends TypedEmitter<DeviceEvents> {
     readonly transport: Transport;
     readonly protocol: TransportProtocol;
-    private readonly transportPath;
+    readonly transportPath: import("@trezor/transport/lib/types").PathPublic;
     private readonly transportSessionOwner;
     private readonly transportDescriptorType;
     private session;
@@ -125,6 +125,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private readonly uniquePath;
     private readonly emitLifecycle;
     private sessionDfd?;
+    handshakeFinished: boolean;
     constructor({ id, transport, descriptor, listener }: DeviceParams);
     private getSessionChangePromise;
     private waitAndCompareSession;

package/lib/device/Device.js

@@ -2,22 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = exports.GET_FEATURES_TIMEOUT = void 0;
 const crypto_1 = require("crypto");
-const utils_1 = require("@trezor/utils");
 const protocol_1 = require("@trezor/protocol");
 const transport_1 = require("@trezor/transport");
+const utils_1 = require("@trezor/utils");
 const DeviceCommands_1 = require("./DeviceCommands");
 const constants_1 = require("../constants");
-const events_1 = require("../events");
-const coinInfo_1 = require("../data/coinInfo");
+const checkFirmwareRevision_1 = require("./checkFirmwareRevision");
+const prompts_1 = require("./prompts");
+const firmware_1 = require("../api/firmware");
 const DataManager_1 = require("../data/DataManager");
+const coinInfo_1 = require("../data/coinInfo");
 const firmwareInfo_1 = require("../data/firmwareInfo");
-const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
-const debug_1 = require("../utils/debug");
-const types_1 = require("../types");
-const models_1 = require("../data/models");
 const getLanguage_1 = require("../data/getLanguage");
-const checkFirmwareRevision_1 = require("./checkFirmwareRevision");
-const firmware_1 = require("../api/firmware");
+const models_1 = require("../data/models");
+const events_1 = require("../events");
+const types_1 = require("../types");
+const debug_1 = require("../utils/debug");
+const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
 const _log = (0, debug_1.initLog)('Device');
 exports.GET_FEATURES_TIMEOUT = 3000;
 exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
@@ -58,6 +59,7 @@ class Device extends utils_1.TypedEmitter {
             firmwareRevision: null,
             firmwareHash: null,
         };
+        this.handshakeFinished = false;
         this.emitLifecycle = listener;
         this.protocol = protocol_1.v1;
         this.uniquePath = id;
@@ -72,7 +74,9 @@ class Device extends utils_1.TypedEmitter {
     getSessionChangePromise() {
         if (!this.sessionDfd) {
             this.sessionDfd = (0, utils_1.createDeferred)();
-            this.sessionDfd.promise.finally(() => {
+            this.sessionDfd.promise
+                .catch(() => { })
+                .finally(() => {
                 this.sessionDfd = undefined;
             });
         }
@@ -198,6 +202,7 @@ class Device extends utils_1.TypedEmitter {
                     }
                 }
             }
+            this.handshakeFinished = true;
             return;
         }
     }
@@ -307,9 +312,16 @@ class Device extends utils_1.TypedEmitter {
                     const getFeaturesTimeout = DataManager_1.DataManager.getSettings('env') === 'react-native'
                         ? exports.GET_FEATURES_TIMEOUT_REACT_NATIVE
                         : exports.GET_FEATURES_TIMEOUT;
+                    let getFeaturesTimeoutId;
                     await Promise.race([
-                        this.getFeatures(),
-                        new Promise((_resolve, reject) => setTimeout(() => reject(new Error('GetFeatures timeout')), getFeaturesTimeout)),
+                        this.getFeatures().finally(() => clearTimeout(getFeaturesTimeoutId)),
+                        new Promise((_resolve, reject) => {
+                            getFeaturesTimeoutId = setTimeout(() => {
+                                (0, prompts_1.cancelPrompt)(this, false).finally(() => {
+                                    reject(new Error('GetFeatures timeout'));
+                                });
+                            }, getFeaturesTimeout);
+                        }),
                     ]);
                 }
             }
@@ -328,9 +340,12 @@ class Device extends utils_1.TypedEmitter {
                 return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}${error.code ? `, code: ${error.code}` : ''}`));
             }
         }
-        await this.checkFirmwareHashWithRetries();
-        await this.checkFirmwareRevisionWithRetries();
-        if (((_b = this.features) === null || _b === void 0 ? void 0 : _b.language) &&
+        if (!options.skipFirmwareChecks) {
+            await this.checkFirmwareHashWithRetries();
+            await this.checkFirmwareRevisionWithRetries();
+        }
+        if (!options.skipLanguageChecks &&
+            ((_b = this.features) === null || _b === void 0 ? void 0 : _b.language) &&
             !this.features.language_version_matches &&
             this.atLeast('2.7.0')) {
             _log.info('language version mismatch. silently updating...');
@@ -509,7 +524,7 @@ class Device extends utils_1.TypedEmitter {
             return { success: true };
         }
         catch (errorPayload) {
-            return createFailResult('other-error', errorPayload);
+            return createFailResult('other-error', (0, utils_1.serializeError)(errorPayload));
         }
     }
     async checkFirmwareRevisionWithRetries() {
@@ -594,7 +609,7 @@ class Device extends utils_1.TypedEmitter {
         if (!feat.model && feat.major_version === 1) {
             feat.model = '1';
         }
-        if (!feat.internal_model) {
+        if (!feat.internal_model || !types_1.DeviceModelInternal[feat.internal_model]) {
             feat.internal_model = (0, deviceFeaturesUtils_1.ensureInternalModelFeature)(feat.model);
         }
         const version = this.getVersion();
@@ -604,6 +619,13 @@ class Device extends utils_1.TypedEmitter {
             feat.patch_version,
         ];
         if (!version || !utils_1.versionUtils.isEqual(version, newVersion)) {
+            if (version) {
+                this.emit(events_1.DEVICE.FIRMWARE_VERSION_CHANGED, {
+                    oldVersion: version,
+                    newVersion,
+                    device: this.toMessageObject(),
+                });
+            }
             this._unavailableCapabilities = (0, deviceFeaturesUtils_1.getUnavailableCapabilities)(feat, (0, coinInfo_1.getAllNetworks)());
             this._firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat);
             this._firmwareRelease = (0, firmwareInfo_1.getRelease)(feat);

package/lib/device/DeviceCommands.d.ts

@@ -1,7 +1,7 @@
-import { Transport, Session } from '@trezor/transport';
 import { MessagesSchema as Messages } from '@trezor/protobuf';
+import { Session, Transport } from '@trezor/transport';
 import { Device } from './Device';
-import type { CoinInfo, BitcoinNetworkInfo } from '../types';
+import type { BitcoinNetworkInfo, CoinInfo } from '../types';
 import type { HDNodeResponse } from '../types/api/getPublicKey';
 type MessageType = Messages.MessageType;
 type MessageKey = keyof MessageType;

package/lib/device/DeviceCommands.js

@@ -2,19 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceCommands = void 0;
 const tslib_1 = require("tslib");
-const crypto_1 = require("crypto");
 const protobuf_1 = require("@trezor/protobuf");
-const utils_1 = require("@trezor/utils");
 const schema_utils_1 = require("@trezor/schema-utils");
+const utils_1 = require("@trezor/utils");
 const constants_1 = require("../constants");
+const resolveDescriptorForTaproot_1 = require("./resolveDescriptorForTaproot");
+const coinInfo_1 = require("../data/coinInfo");
 const events_1 = require("../events");
-const hdnodeUtils = tslib_1.__importStar(require("../utils/hdnodeUtils"));
-const pathUtils_1 = require("../utils/pathUtils");
+const prompts_1 = require("./prompts");
 const accountUtils_1 = require("../utils/accountUtils");
-const coinInfo_1 = require("../data/coinInfo");
 const debug_1 = require("../utils/debug");
-const resolveDescriptorForTaproot_1 = require("./resolveDescriptorForTaproot");
-const prompts_1 = require("./prompts");
+const hdnodeUtils = tslib_1.__importStar(require("../utils/hdnodeUtils"));
+const pathUtils_1 = require("../utils/pathUtils");
 const logger = (0, debug_1.initLog)('DeviceCommands');
 const assertType = (res, resType) => {
     const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
@@ -22,17 +21,31 @@ const assertType = (res, resType) => {
         throw constants_1.ERRORS.TypedError('Runtime', `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
     }
 };
-const generateEntropy = (len) => {
-    try {
-        return (0, crypto_1.randomBytes)(len);
-    }
-    catch {
-        throw constants_1.ERRORS.TypedError('Runtime', 'generateEntropy: Environment does not support crypto random');
-    }
-};
 const filterForLog = (type, msg) => {
-    const blacklist = {};
+    const blacklist = {
+        PassphraseAck: {
+            passphrase: '(redacted...)',
+        },
+        CipheredKeyValue: {
+            value: '(redacted...)',
+        },
+        GetPublicKey: {
+            address_n: '(redacted...)',
+        },
+        PublicKey: {
+            node: '(redacted...)',
+            xpub: '(redacted...)',
+        },
+        DecryptedMessage: {
+            message: '(redacted...)',
+            address: '(redacted...)',
+        },
+        Features: '(redacted...)',
+    };
     if (type in blacklist) {
+        if (typeof blacklist[type] === 'string') {
+            return blacklist[type];
+        }
         return { ...msg, ...blacklist[type] };
     }
     return msg;
@@ -227,9 +240,18 @@ class DeviceCommands {
             assertType(response, resType);
         }
         catch (error) {
-            await this.transport.receive({
+            const abortController = new AbortController();
+            const timeout = setTimeout(() => {
+                abortController.abort();
+            }, 500);
+            await this.transport
+                .receive({
                 session: this.transportSession,
                 protocol: this.device.protocol,
+                signal: abortController.signal,
+            })
+                .finally(() => {
+                clearTimeout(timeout);
             });
             throw error;
         }
@@ -268,11 +290,6 @@ class DeviceCommands {
             }
             return this._commonCall('ButtonAck', {});
         }
-        if (res.type === 'EntropyRequest') {
-            return this._commonCall('EntropyAck', {
-                entropy: generateEntropy(32).toString('hex'),
-            });
-        }
         if (res.type === 'PinMatrixRequest') {
             return (0, prompts_1.promptPin)(this.device, res.message.type).then(pin => this._commonCall('PinMatrixAck', { pin }).then(response => {
                 if (!this.device.features.unlocked) {
@@ -282,11 +299,9 @@ class DeviceCommands {
             }), error => Promise.reject(error));
         }
         if (res.type === 'PassphraseRequest') {
-            return (0, prompts_1.promptPassphrase)(this.device).then(({ value, passphraseOnDevice }) => {
-                return !passphraseOnDevice
-                    ? this._commonCall('PassphraseAck', { passphrase: value.normalize('NFKD') })
-                    : this._commonCall('PassphraseAck', { on_device: true });
-            }, error => Promise.reject(error));
+            return (0, prompts_1.promptPassphrase)(this.device).then(({ value, passphraseOnDevice }) => !passphraseOnDevice
+                ? this._commonCall('PassphraseAck', { passphrase: value.normalize('NFKD') })
+                : this._commonCall('PassphraseAck', { on_device: true }), error => Promise.reject(error));
         }
         if (res.type === 'WordRequest') {
             return (0, prompts_1.promptWord)(this.device, res.message.type).then(word => this._commonCall('WordAck', { word }), error => Promise.reject(error));

package/lib/device/DeviceList.d.ts

@@ -1,20 +1,20 @@
+import { TRANSPORT } from '@trezor/transport';
+import type { TransportApiType } from '@trezor/transport/lib/transports/abstract';
 import { TypedEmitter } from '@trezor/utils';
-import { Transport, TRANSPORT } from '@trezor/transport';
-import { DEVICE, TransportInfo } from '../events';
+import { DEVICE, TransportError, TransportInfo } from '../events';
 import { Device } from './Device';
-import { ConnectSettings, DeviceUniquePath, Device as DeviceTyped, StaticSessionId } from '../types';
+import { ConnectSettings, DeviceUniquePath, StaticSessionId } from '../types';
 interface DeviceListEvents {
     [TRANSPORT.START]: TransportInfo;
-    [TRANSPORT.ERROR]: string;
-    [DEVICE.CONNECT]: DeviceTyped;
-    [DEVICE.CONNECT_UNACQUIRED]: DeviceTyped;
-    [DEVICE.DISCONNECT]: DeviceTyped;
-    [DEVICE.CHANGED]: DeviceTyped;
+    [TRANSPORT.ERROR]: TransportError;
+    [DEVICE.CONNECT]: Device;
+    [DEVICE.CONNECT_UNACQUIRED]: Device;
+    [DEVICE.DISCONNECT]: Device;
+    [DEVICE.CHANGED]: Device;
 }
 export interface IDeviceList {
     isConnected(): this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
-    setTransports: DeviceList['setTransports'];
     addAuthPenalty: DeviceList['addAuthPenalty'];
     removeAuthPenalty: DeviceList['removeAuthPenalty'];
     on: DeviceList['on'];
@@ -26,42 +26,47 @@ export declare const assertDeviceListConnected: (deviceList: IDeviceList) => ass
 type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | '_sessionsBackgroundUrl' | 'manifest'> & {
     messages: Record<string, any>;
 };
-type InitParams = Pick<ConnectSettings, 'pendingTransportEvent' | 'transportReconnect'>;
+type InitParams = Pick<ConnectSettings, 'transports' | 'pendingTransportEvent' | 'transportReconnect'>;
 export declare class DeviceList extends TypedEmitter<DeviceListEvents> implements IDeviceList {
-    private transport;
+    private readonly transport;
     private transports;
-    private devices;
+    private readonly devices;
     private deviceCounter;
     private readonly handshakeLock;
     private readonly authPenaltyManager;
-    private initPromise?;
-    private rejectPending?;
     private transportCommonArgs;
     isConnected(): this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
+    getActiveTransports(): {
+        apiType: TransportApiType;
+        type: "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport" | "NativeUsbTransport" | "BluetoothTransport";
+        version: string;
+        outdated: boolean;
+    }[];
+    private readonly locks;
+    private transportLock;
     constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }: ConstructorParams);
-    private createTransport;
-    setTransports(transports: ConnectSettings['transports']): void;
+    private tryGetTransport;
+    private getOrCreateTransport;
+    private createTransports;
     private onDeviceConnected;
     private onDeviceDisconnected;
     private onDeviceSessionChanged;
     private onDeviceRequestRelease;
     init(initParams?: InitParams): Promise<void>;
     private createInitPromise;
-    private createReconnectPromise;
+    private createReconnectDelay;
     private selectTransport;
     private initializeTransport;
     private waitForDevices;
     getDeviceCount(): number;
-    getAllDevices(): Device[];
+    getAllDevices(): readonly Device[];
     getOnlyDevice(): Device | undefined;
     getDeviceByPath(path: DeviceUniquePath): Device | undefined;
     getDeviceByStaticState(state: StaticSessionId): Device | undefined;
-    transportType(): "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport" | "NativeUsbTransport" | "BluetoothTransport";
-    getTransportInfo(): TransportInfo;
     dispose(): Promise<void>;
-    cleanup(): Promise<void>;
-    enumerate(transport?: Transport): Promise<void>;
+    private stopTransport;
+    enumerate(): Promise<void>;
     addAuthPenalty(device: Device): void;
     removeAuthPenalty(device: Device): void;
 }