@trezor/connect 9.3.1-beta.2 → 9.4.0

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,4 +1,4 @@
-export declare const VERSION = "9.3.1-beta.2";
+export declare const VERSION = "9.4.0";
 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.3.1-beta.2';
+exports.VERSION = '9.4.0';
 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

@@ -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;
@@ -52,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;
@@ -73,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;
@@ -90,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

@@ -15,6 +15,7 @@ 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;
@@ -39,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;
         }
@@ -187,7 +191,8 @@ class Device extends utils_1.TypedEmitter {
                 }
             }
             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);
                 }
@@ -304,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')) {
@@ -316,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);
@@ -550,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/DeviceList.d.ts

@@ -15,7 +15,6 @@ interface DeviceListEvents {
 }
 export interface IDeviceList {
     isConnected(): this is DeviceList;
-    assertConnected(): asserts this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
     setTransports: DeviceList['setTransports'];
     addAuthPenalty: DeviceList['addAuthPenalty'];
@@ -25,6 +24,7 @@ export interface IDeviceList {
     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>;
 };
@@ -39,7 +39,6 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
     private rejectPending?;
     private transportCommonArgs;
     isConnected(): this is DeviceList;
-    assertConnected(): asserts this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
     constructor({ messages, priority, debug }: ConstructorParams);
     private createTransport;

package/lib/device/DeviceList.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceList = void 0;
+exports.DeviceList = exports.assertDeviceListConnected = void 0;
 const utils_1 = require("@trezor/utils");
 const transport_1 = require("@trezor/transport");
 const constants_1 = require("../constants");
@@ -30,14 +30,15 @@ const createAuthPenaltyManager = (priority) => {
     const clear = () => Object.keys(penalizedDevices).forEach(key => delete penalizedDevices[key]);
     return { get, add, remove, clear };
 };
+const assertDeviceListConnected = deviceList => {
+    if (!deviceList.isConnected())
+        throw constants_1.ERRORS.TypedError('Transport_Missing');
+};
+exports.assertDeviceListConnected = assertDeviceListConnected;
 class DeviceList extends utils_1.TypedEmitter {
     isConnected() {
         return !!this.transport;
     }
-    assertConnected() {
-        if (!this.transport)
-            throw constants_1.ERRORS.TypedError('Transport_Missing');
-    }
     pendingConnection() {
         return this.initPromise;
     }

package/lib/device/calculateRevisionForDevice.d.ts

@@ -0,0 +1,8 @@
+import { VersionArray } from '../exports';
+type calculateRevisionForDeviceParams = {
+    commitRevision: string;
+    version: VersionArray;
+};
+export declare const calculateRevisionForDevice: ({ commitRevision, version, }: calculateRevisionForDeviceParams) => string;
+export {};
+//# sourceMappingURL=calculateRevisionForDevice.d.ts.map

package/lib/device/calculateRevisionForDevice.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRevisionForDevice = void 0;
+const versionUtils_1 = require("@trezor/utils/lib/versionUtils");
+const calculateRevisionForDevice = ({ commitRevision, version, }) => {
+    if ((0, versionUtils_1.isNewer)(version, '2.4.0')) {
+        return commitRevision;
+    }
+    if ((0, versionUtils_1.isNewer)(version, '2.2.0')) {
+        return commitRevision.slice(0, 9);
+    }
+    if ((0, versionUtils_1.isNewer)(version, '2.1.8')) {
+        return commitRevision;
+    }
+    if ((0, versionUtils_1.isNewer)(version, '2.0.0')) {
+        return commitRevision.slice(0, 8);
+    }
+    return commitRevision;
+};
+exports.calculateRevisionForDevice = calculateRevisionForDevice;
+//# sourceMappingURL=calculateRevisionForDevice.js.map

package/lib/device/checkFirmwareRevision.d.ts

@@ -0,0 +1,11 @@
+import { PROTO } from '../constants';
+import { VersionArray } from '../types';
+import { FirmwareRevisionCheckResult } from '../types/device';
+export type CheckFirmwareRevisionParams = {
+    firmwareVersion: VersionArray;
+    internalModel: PROTO.DeviceModelInternal;
+    deviceRevision: string | null;
+    expectedRevision: string | undefined;
+};
+export declare const checkFirmwareRevision: ({ firmwareVersion, internalModel, deviceRevision, expectedRevision, }: CheckFirmwareRevisionParams) => Promise<FirmwareRevisionCheckResult>;
+//# sourceMappingURL=checkFirmwareRevision.d.ts.map

package/lib/device/checkFirmwareRevision.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFirmwareRevision = void 0;
+const versionUtils_1 = require("@trezor/utils/lib/versionUtils");
+const downloadReleasesMetadata_1 = require("../data/downloadReleasesMetadata");
+const device_1 = require("../types/device");
+const calculateRevisionForDevice_1 = require("./calculateRevisionForDevice");
+const getOnlineReleaseMetadata = async ({ firmwareVersion, internalModel, }) => {
+    const onlineReleases = await (0, downloadReleasesMetadata_1.downloadReleasesMetadata)({ internal_model: internalModel });
+    return onlineReleases.find(onlineRelease => (0, versionUtils_1.isEqual)(onlineRelease.version, firmwareVersion));
+};
+const failFirmwareRevisionCheck = (error) => ({ success: false, error });
+const doRevisionsMatch = ({ deviceRevision, expectedCommitRevision, firmwareVersion, }) => {
+    if (deviceRevision === null) {
+        return false;
+    }
+    const adjustedExpected = (0, calculateRevisionForDevice_1.calculateRevisionForDevice)({
+        commitRevision: expectedCommitRevision,
+        version: firmwareVersion,
+    });
+    return adjustedExpected === deviceRevision;
+};
+const checkFirmwareRevision = async ({ firmwareVersion, internalModel, deviceRevision, expectedRevision, }) => {
+    if (internalModel !== device_1.DeviceModelInternal.T2T1 && internalModel !== device_1.DeviceModelInternal.T1B1) {
+        return { success: true };
+    }
+    if (expectedRevision === undefined) {
+        if (firmwareVersion.length !== 3) {
+            return failFirmwareRevisionCheck('firmware-version-unknown');
+        }
+        try {
+            const onlineRelease = await getOnlineReleaseMetadata({
+                firmwareVersion,
+                internalModel,
+            });
+            if ((onlineRelease === null || onlineRelease === void 0 ? void 0 : onlineRelease.firmware_revision) === undefined) {
+                return failFirmwareRevisionCheck('firmware-version-unknown');
+            }
+            if (!doRevisionsMatch({
+                deviceRevision,
+                expectedCommitRevision: onlineRelease.firmware_revision,
+                firmwareVersion,
+            })) {
+                return failFirmwareRevisionCheck('revision-mismatch');
+            }
+            return { success: true };
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: 'cannot-perform-check-offline',
+            };
+        }
+    }
+    if (!doRevisionsMatch({
+        deviceRevision,
+        expectedCommitRevision: expectedRevision,
+        firmwareVersion,
+    })) {
+        return failFirmwareRevisionCheck('revision-mismatch');
+    }
+    return { success: true };
+};
+exports.checkFirmwareRevision = checkFirmwareRevision;
+//# sourceMappingURL=checkFirmwareRevision.js.map

package/lib/types/device.d.ts

@@ -11,6 +11,12 @@ export declare enum FirmwareType {
 export type UnavailableCapabilities = {
     [key: string]: UnavailableCapability;
 };
+export type FirmwareRevisionCheckResult = {
+    success: true;
+} | {
+    success: false;
+    error: 'revision-mismatch' | 'firmware-version-unknown' | 'firmware-version-unknown' | 'cannot-perform-check-offline';
+};
 export type KnownDevice = {
     type: 'acquired';
     id: string | null;
@@ -28,6 +34,9 @@ export type KnownDevice = {
     features: PROTO.Features;
     unavailableCapabilities: UnavailableCapabilities;
     availableTranslations: string[];
+    authenticityChecks?: {
+        firmwareRevision: FirmwareRevisionCheckResult | null;
+    };
 };
 export type UnknownDevice = {
     type: 'unacquired';

package/lib/types/firmware.d.ts

@@ -10,6 +10,7 @@ export type FirmwareRelease = {
     fingerprint: string;
     changelog: string | string[];
     changelog_bitcoinonly?: string | string[];
+    firmware_revision?: string;
     version: VersionArray;
     min_firmware_version: VersionArray;
     min_bootloader_version: VersionArray;

package/lib/utils/assets-browser.d.ts

@@ -1,2 +1,2 @@
-export declare const httpRequest: (url: string, type?: 'text' | 'binary' | 'json') => Promise<any>;
+export declare const httpRequest: (url: string, type?: 'text' | 'binary' | 'json', options?: RequestInit) => Promise<any>;
 //# sourceMappingURL=assets-browser.d.ts.map

package/lib/utils/assets-browser.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.httpRequest = void 0;
 const tslib_1 = require("tslib");
 const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
-const httpRequest = async (url, type = 'text') => {
-    const response = await (0, cross_fetch_1.default)(url, { credentials: 'same-origin' });
+const httpRequest = async (url, type = 'text', options) => {
+    const init = { ...options, credentials: 'same-origin' };
+    const response = await (0, cross_fetch_1.default)(url, init);
     if (response.ok) {
         if (type === 'json') {
             const txt = await response.text();

package/lib/utils/assets.d.ts

@@ -1,4 +1,4 @@
-export declare function httpRequest(url: string, type: 'text'): Promise<string>;
-export declare function httpRequest(url: string, type: 'binary'): Promise<ArrayBuffer>;
-export declare function httpRequest(url: string, type: 'json'): Promise<Record<string, any>>;
+export declare function httpRequest(url: string, type: 'text', options?: RequestInit, skipLocalForceDownload?: boolean): Promise<string>;
+export declare function httpRequest(url: string, type: 'binary', options?: RequestInit, skipLocalForceDownload?: boolean): Promise<ArrayBuffer>;
+export declare function httpRequest(url: string, type: 'json', options?: RequestInit, skipLocalForceDownload?: boolean): Promise<Record<string, any>>;
 //# sourceMappingURL=assets.d.ts.map

package/lib/utils/assets.js

@@ -9,10 +9,10 @@ const assetUtils_1 = require("./assetUtils");
 if (global && typeof global.fetch !== 'function') {
     global.fetch = cross_fetch_1.default;
 }
-function httpRequest(url, type) {
-    const asset = (0, assetUtils_1.getAssetByUrl)(url);
+function httpRequest(url, type, options, skipLocalForceDownload) {
+    const asset = skipLocalForceDownload ? null : (0, assetUtils_1.getAssetByUrl)(url);
     if (!asset) {
-        return /^https?/.test(url) ? (0, assets_browser_1.httpRequest)(url, type) : fs_1.promises.readFile(url);
+        return /^https?/.test(url) ? (0, assets_browser_1.httpRequest)(url, type, options) : fs_1.promises.readFile(url);
     }
     return asset;
 }

package/lib/utils/deviceFeaturesUtils.js

@@ -44,10 +44,22 @@ const getUnavailableCapabilities = (features, coins) => {
         return list;
     const fw = [features.major_version, features.minor_version, features.patch_version].join('.');
     const key = features.internal_model;
+    const duplicatedShortcuts = ['bnb'];
     const supported = coins.filter(info => {
         if (!info.support || info.support[key] === false) {
-            list[info.shortcut.toLowerCase()] = 'no-support';
-            return false;
+            const shortcut = info.shortcut.toLowerCase();
+            if (!duplicatedShortcuts.includes(shortcut)) {
+                list[shortcut] = 'no-support';
+                return false;
+            }
+            else {
+                const occurrences = coins.filter(coin => shortcut == coin.shortcut.toLowerCase());
+                const allUnsupported = occurrences.every(info => !info.support || info.support[key] === false);
+                if (allUnsupported) {
+                    list[shortcut] = 'no-support';
+                }
+                return false;
+            }
         }
         return true;
     });
@@ -64,14 +76,18 @@ const getUnavailableCapabilities = (features, coins) => {
         if (info.type === 'nem') {
             return !capabilities.includes('Capability_NEM');
         }
-        if (info.shortcut === 'BNB')
+        if (info.shortcut === 'BNB' && info.type === 'misc') {
             return !capabilities.includes('Capability_Binance');
-        if (info.shortcut === 'ADA' || info.shortcut === 'tADA')
+        }
+        if (info.shortcut === 'ADA' || info.shortcut === 'tADA') {
             return !capabilities.includes('Capability_Cardano');
-        if (info.shortcut === 'XRP' || info.shortcut === 'tXRP')
+        }
+        if (info.shortcut === 'XRP' || info.shortcut === 'tXRP') {
             return !capabilities.includes('Capability_Ripple');
-        if (info.shortcut === 'SOL' || info.shortcut === 'DSOL')
+        }
+        if (info.shortcut === 'SOL' || info.shortcut === 'DSOL') {
             return !capabilities.includes('Capability_Solana');
+        }
         return !capabilities.includes(`Capability_${info.name}`);
     });
     unavailable.forEach(info => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.3.1-beta.2",
+  "version": "9.4.0",
   "author": "Trezor <info@trezor.io>",
   "homepage": "https://github.com/trezor/trezor-suite/tree/develop/packages/connect",
   "description": "High-level javascript interface for Trezor hardware wallet.",
@@ -71,16 +71,16 @@
     "@ethereumjs/common": "^4.3.0",
     "@ethereumjs/tx": "^5.3.0",
     "@fivebinaries/coin-selection": "2.2.1",
-    "@trezor/blockchain-link": "2.2.1-beta.2",
-    "@trezor/blockchain-link-types": "1.1.1-beta.2",
-    "@trezor/connect-analytics": "1.1.0",
-    "@trezor/connect-common": "0.1.1-beta.2",
-    "@trezor/protobuf": "1.1.1-beta.2",
-    "@trezor/protocol": "1.1.1-beta.1",
-    "@trezor/schema-utils": "1.1.1-beta.1",
-    "@trezor/transport": "1.2.1-beta.2",
-    "@trezor/utils": "9.1.1-beta.2",
-    "@trezor/utxo-lib": "2.1.1-beta.1",
+    "@trezor/blockchain-link": "2.3.0",
+    "@trezor/blockchain-link-types": "1.2.0",
+    "@trezor/connect-analytics": "1.2.0",
+    "@trezor/connect-common": "0.2.0",
+    "@trezor/protobuf": "1.2.0",
+    "@trezor/protocol": "1.2.0",
+    "@trezor/schema-utils": "1.2.0",
+    "@trezor/transport": "1.3.0",
+    "@trezor/utils": "9.2.0",
+    "@trezor/utxo-lib": "2.2.0",
     "blakejs": "^1.2.1",
     "bs58": "^5.0.0",
     "bs58check": "^3.0.1",