@trezor/connect 9.3.1-beta.1 → 9.3.1-beta.3

package/lib/data/DataManager.d.ts

@@ -66,6 +66,11 @@ export declare class DataManager {
                 download: string;
                 update: string;
             };
+            opera: {
+                version: number;
+                download: string;
+                update: string;
+            };
         };
         supportedFirmware: ({
             coin: string[];

package/lib/data/config.d.ts

@@ -54,6 +54,11 @@ export declare const config: {
             download: string;
             update: string;
         };
+        opera: {
+            version: number;
+            download: string;
+            update: string;
+        };
     };
     supportedFirmware: ({
         coin: string[];

package/lib/data/config.js

@@ -128,6 +128,11 @@ exports.config = {
             download: 'https://www.microsoft.com/en-us/edge',
             update: 'https://www.microsoft.com/en-us/edge',
         },
+        opera: {
+            version: 95,
+            download: 'https://www.opera.com/download',
+            update: 'https://www.opera.com/download',
+        },
     },
     supportedFirmware: [
         {

package/lib/data/downloadReleasesMetadata.d.ts

@@ -0,0 +1,7 @@
+import { FirmwareRelease } from '../types';
+type DownloadReleasesMetadataParams = {
+    internal_model: string;
+};
+export declare const downloadReleasesMetadata: ({ internal_model, }: DownloadReleasesMetadataParams) => Promise<FirmwareRelease[]>;
+export {};
+//# sourceMappingURL=downloadReleasesMetadata.d.ts.map

package/lib/data/downloadReleasesMetadata.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadReleasesMetadata = void 0;
+const assets_1 = require("../utils/assets");
+const firmwareUtils_1 = require("../utils/firmwareUtils");
+const downloadReleasesMetadata = async ({ internal_model, }) => {
+    const url = `https://data.trezor.io/firmware/${internal_model.toLowerCase()}/releases.json`;
+    const response = (await (0, assets_1.httpRequest)(url, 'json', { signal: AbortSignal.timeout(10000) }, true));
+    if ((0, firmwareUtils_1.isValidReleases)(response)) {
+        return response;
+    }
+    return [];
+};
+exports.downloadReleasesMetadata = downloadReleasesMetadata;
+//# sourceMappingURL=downloadReleasesMetadata.js.map

package/lib/data/version.d.ts

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

package/lib/data/version.js

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

package/lib/device/Device.d.ts

@@ -5,7 +5,7 @@ import { DeviceCommands, PassphrasePromptResponse } from './DeviceCommands';
 import { PROTO, NETWORK } from '../constants';
 import { DEVICE, DeviceButtonRequestPayload } from '../events';
 import { type Transport, type Descriptor } from '@trezor/transport';
-import { Device as DeviceTyped, DeviceFirmwareStatus, Features, ReleaseInfo, UnavailableCapabilities, FirmwareType } from '../types';
+import { Device as DeviceTyped, DeviceFirmwareStatus, Features, ReleaseInfo, UnavailableCapabilities, FirmwareType, VersionArray, KnownDevice } from '../types';
 export type RunOptions = {
     skipFinalReload?: boolean;
     waiting?: boolean;
@@ -15,6 +15,7 @@ export type RunOptions = {
     useCardanoDerivation?: boolean;
 };
 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;
@@ -51,6 +52,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     name: string;
     color?: string;
     availableTranslations: string[];
+    authenticityChecks: NonNullable<KnownDevice['authenticityChecks']>;
     constructor(transport: Transport, descriptor: Descriptor);
     static fromDescriptor(transport: Transport, originalDescriptor: Descriptor): Device;
     static createUnacquired(transport: Transport, descriptor: Descriptor, unreadableError?: string): Device;
@@ -72,6 +74,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     validateState(preauthorized?: boolean): Promise<string | undefined>;
     initialize(useCardanoDerivation: boolean): Promise<void>;
     getFeatures(): Promise<void>;
+    checkFirmwareRevision(): Promise<void>;
     changeLanguage({ language, binary, }: {
         language?: undefined;
         binary: ArrayBuffer;
@@ -89,7 +92,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     isInitialized(): boolean;
     isSeedless(): boolean;
     isInconsistent(): boolean;
-    getVersion(): never[] | [number, number, number];
+    getVersion(): VersionArray | [];
     atLeast(versions: string[] | string): boolean;
     isUsed(): boolean;
     isUsedHere(): boolean;

package/lib/device/Device.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Device = exports.GET_FEATURES_TIMEOUT = void 0;
+exports.Device = exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = exports.GET_FEATURES_TIMEOUT = void 0;
 const utils_1 = require("@trezor/utils");
 const protocol_1 = require("@trezor/protocol");
 const DeviceCommands_1 = require("./DeviceCommands");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const coinInfo_1 = require("../data/coinInfo");
+const DataManager_1 = require("../data/DataManager");
 const firmwareInfo_1 = require("../data/firmwareInfo");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
 const debug_1 = require("../utils/debug");
@@ -14,8 +15,10 @@ const transport_1 = require("@trezor/transport");
 const types_1 = require("../types");
 const models_1 = require("../data/models");
 const getLanguage_1 = require("../data/getLanguage");
+const checkFirmwareRevision_1 = require("./checkFirmwareRevision");
 const _log = (0, debug_1.initLog)('Device');
 exports.GET_FEATURES_TIMEOUT = 3000;
+exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
 const parseRunOptions = (options) => {
     if (!options)
         options = {};
@@ -37,6 +40,9 @@ class Device extends utils_1.TypedEmitter {
         this.networkTypeState = [];
         this.name = 'Trezor';
         this.availableTranslations = [];
+        this.authenticityChecks = {
+            firmwareRevision: null,
+        };
         if (transport.name === 'BridgeTransport') {
             this.protocol = protocol_1.bridge;
         }
@@ -175,14 +181,18 @@ class Device extends utils_1.TypedEmitter {
                     await this.initialize(!!options.useCardanoDerivation);
                 }
                 else {
+                    const getFeaturesTimeout = DataManager_1.DataManager.getSettings('env') === 'react-native'
+                        ? exports.GET_FEATURES_TIMEOUT_REACT_NATIVE
+                        : exports.GET_FEATURES_TIMEOUT;
                     await Promise.race([
                         this.getFeatures(),
-                        new Promise((_resolve, reject) => setTimeout(() => reject(new Error('GetFeatures timeout')), exports.GET_FEATURES_TIMEOUT)),
+                        new Promise((_resolve, reject) => setTimeout(() => reject(new Error('GetFeatures timeout')), getFeaturesTimeout)),
                     ]);
                 }
             }
             catch (error) {
-                if (!this.inconsistent && error.message === 'GetFeatures timeout') {
+                if (!this.inconsistent &&
+                    (error.message === 'GetFeatures timeout' || error.message === 'Unknown message')) {
                     this.inconsistent = true;
                     return this._runInner(() => Promise.resolve({}), options);
                 }
@@ -191,7 +201,7 @@ class Device extends utils_1.TypedEmitter {
                 }
                 this.inconsistent = true;
                 delete this.runPromise;
-                return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message} ${error.code ? `, code: ${error.code}` : ''}`));
+                return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}${error.code ? `, code: ${error.code}` : ''}`));
             }
         }
         if (options.keepSession) {
@@ -299,6 +309,11 @@ class Device extends utils_1.TypedEmitter {
     async getFeatures() {
         const { message } = await this.getCommands().typedCall('GetFeatures', 'Features', {});
         this._updateFeatures(message);
+        if (this.authenticityChecks.firmwareRevision === null ||
+            (this.authenticityChecks.firmwareRevision.success === false &&
+                this.authenticityChecks.firmwareRevision.error === 'cannot-perform-check-offline')) {
+            await this.checkFirmwareRevision();
+        }
         if (!this.features.language_version_matches &&
             this.features.language &&
             this.atLeast('2.7.0')) {
@@ -311,6 +326,25 @@ class Device extends utils_1.TypedEmitter {
             }
         }
     }
+    async checkFirmwareRevision() {
+        const firmwareVersion = this.getVersion();
+        if (firmwareVersion.length === 0 || !this.features) {
+            return;
+        }
+        if (this.features.bootloader_mode === true) {
+            return;
+        }
+        const releases = (0, firmwareInfo_1.getReleases)(this.features.internal_model);
+        const release = releases.find(r => firmwareVersion &&
+            utils_1.versionUtils.isVersionArray(firmwareVersion) &&
+            utils_1.versionUtils.isEqual(r.version, firmwareVersion));
+        this.authenticityChecks.firmwareRevision = await (0, checkFirmwareRevision_1.checkFirmwareRevision)({
+            internalModel: this.features.internal_model,
+            deviceRevision: this.features.revision,
+            firmwareVersion,
+            expectedRevision: release === null || release === void 0 ? void 0 : release.firmware_revision,
+        });
+    }
     async changeLanguage({ language, binary, }) {
         if (language === 'en-US') {
             return this._uploadTranslationData(null);
@@ -545,6 +579,7 @@ class Device extends utils_1.TypedEmitter {
             features: this.features,
             unavailableCapabilities: this.unavailableCapabilities,
             availableTranslations: this.availableTranslations,
+            authenticityChecks: this.authenticityChecks,
         };
     }
     async legacyForceRelease() {

package/lib/device/DeviceCommands.js

@@ -230,7 +230,7 @@ class DeviceCommands {
             await this.transport.receive({
                 session: this.sessionId,
                 protocol: this.device.protocol,
-            });
+            }).promise;
             throw error;
         }
         return response;

package/lib/device/DeviceList.d.ts

@@ -1,5 +1,5 @@
 import { TypedEmitter } from '@trezor/utils';
-import { Transport, TRANSPORT, Descriptor } from '@trezor/transport';
+import { Transport, TRANSPORT } from '@trezor/transport';
 import { DEVICE, TransportInfo } from '../events';
 import { Device } from './Device';
 import type { ConnectSettings, Device as DeviceTyped } from '../types';
@@ -13,28 +13,43 @@ interface DeviceListEvents {
     [DEVICE.RELEASED]: DeviceTyped;
     [DEVICE.ACQUIRED]: DeviceTyped;
 }
-export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
-    transport: Transport;
-    transports: Transport[];
-    devices: {
-        [path: string]: Device;
-    };
-    creatingDevicesDescriptors: {
-        [k: string]: Descriptor;
-    };
-    transportStartPending: number;
-    penalizedDevices: {
-        [deviceID: string]: number;
-    };
-    transportFirstEventPromise: Promise<void> | undefined;
-    private settings;
-    constructor({ settings, messages, }: {
-        settings: ConnectSettings;
-        messages: Record<string, any>;
-    });
-    init(): Promise<void>;
-    private resolveTransportEvent;
-    waitForTransportFirstEvent(): Promise<void>;
+export interface IDeviceList {
+    isConnected(): this is DeviceList;
+    pendingConnection(): Promise<void> | undefined;
+    setTransports: DeviceList['setTransports'];
+    addAuthPenalty: DeviceList['addAuthPenalty'];
+    removeAuthPenalty: DeviceList['removeAuthPenalty'];
+    on: DeviceList['on'];
+    once: DeviceList['once'];
+    init: DeviceList['init'];
+    dispose: DeviceList['dispose'];
+}
+export declare const assertDeviceListConnected: (deviceList: IDeviceList) => asserts deviceList is DeviceList;
+type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug'> & {
+    messages: Record<string, any>;
+};
+type InitParams = Pick<ConnectSettings, 'pendingTransportEvent' | 'transportReconnect'>;
+export declare class DeviceList extends TypedEmitter<DeviceListEvents> implements IDeviceList {
+    private transport;
+    private transports;
+    private devices;
+    private creatingDevicesDescriptors;
+    private readonly authPenaltyManager;
+    private initPromise?;
+    private rejectPending?;
+    private transportCommonArgs;
+    isConnected(): this is DeviceList;
+    pendingConnection(): Promise<void> | undefined;
+    constructor({ messages, priority, debug }: ConstructorParams);
+    private createTransport;
+    setTransports(transports: ConnectSettings['transports']): void;
+    private onTransportUpdate;
+    init(initParams?: InitParams): Promise<void>;
+    private createInitPromise;
+    private createReconnectPromise;
+    private selectTransport;
+    private initializeTransport;
+    private waitForDevices;
     private _createAndSaveDevice;
     private _createUnacquiredDevice;
     private _createUnreadableDevice;
@@ -45,11 +60,10 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
     length(): number;
     transportType(): "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport";
     getTransportInfo(): TransportInfo;
-    dispose(): void;
-    disconnectDevices(): void;
-    enumerate(): Promise<void>;
+    dispose(): Promise<void>;
+    cleanup(): Promise<void>;
+    enumerate(transport?: Transport): Promise<void>;
     addAuthPenalty(device: Device): void;
-    private getAuthPenalty;
     removeAuthPenalty(device: Device): void;
     private handle;
     private _takeAndCreateDevice;