@trezor/connect 9.4.2-beta.2 → 9.4.3-beta.1

package/CHANGELOG.md

@@ -1,16 +1,61 @@
 |             Package              | Stable |    Canary    |
 | :------------------------------: | :----: | :----------: |
-|       npm @trezor/connect        | 9.4.1  | 9.4.2-beta.2 |
-|     npm @trezor/connect-web      | 9.4.1  | 9.4.2-beta.2 |
-| npm @trezor/connect-webextension | 9.4.1  | 9.4.2-beta.2 |
+|       npm @trezor/connect        | 9.4.2  | 9.4.3-beta.1 |
+|     npm @trezor/connect-web      | 9.4.2  | 9.4.3-beta.1 |
+| npm @trezor/connect-webextension | 9.4.2  | 9.4.3-beta.1 |
 
 |     Deployment     | Stable |    Canary    |
 | :----------------: | :----: | :----------: |
-| connect.trezor.io/ | 9.4.1  | 9.4.2-beta.2 |
+| connect.trezor.io/ | 9.4.2  | 9.4.3-beta.1 |
 
 Use the persistent link [connect.trezor.io/9](https://connect.trezor.io/9/) to access the latest stable version of Connect Explorer.
 
-# 9.4.2-beta.2
+# 9.4.3-beta.1
+
+This release introduces `@trezor/connect-mobile`, which allows mobile apps to integrate with Trezor Suite mobile using deeplinks.
+This package is still beta and work in progress.
+
+### Connect Mobile related changes
+
+-   chore(connect-mobile): update package.json for publishing (fb157ef318)
+-   feat(connect-explorer): hiding beta-only content (21e0d42c6d)
+-   feat(connect-explorer): call deeplinks from method tester (f2a5f7460e)
+-   docs(connect): mobile connect popup (9f8f1c1bd2)
+-   chore(connect-popup): move deeplink fallback page to versioned url (e86e6aa5b3)
+-   chore: rename connect-deeplink to connect-mobile (d1c2bd7464)
+-   feat(connect): use separate versioning for deeplink protocol (40f3b53a34)
+-   feat(module-connect-popup): add version check to app link parser (fe8499ec1c)
+-   chore(connect-examples): change from deeplinkUrl to connectSrc (1ff479c545)
+-   feat(connect): take deeplinkUrl from connectSrc (1b88b3b72b)
+
+### Other changes
+
+-   refactor(connect-web): use dynamic from connect package (887889288f)
+-   refactor(connect): dynamic connect (96e81fe5bf)
+-   fix(connect): make getBinaryOptional async (e583e84c32)
+-   test(connect-popup): fix log going to (9dee606f43)
+-   feat(connect): fw hash check automatically for T1B1 (0fd023dbe8)
+-   docs(connect-web): Support matrix (44ed16a45d)
+-   chore: update backends for bsc and op (458f0fe3d9)
+-   docs(connect-explorer): mention address can be used in getAccountInfo (722a2b2b7f)
+-   chore(connect): cleanup some duplicities in fw download util (53456df94d)
+-   chore(connect): a cosmetic change in Device types (b718af4a2b)
+-   chore(connect): use import from @trezor/connect-analytics (1ee270b1cd)
+-   chore(protobuf): update messages.json (71bbde850b)
+-   feat(connect): add Optimism (c2fb244649)
+-   chore(connect): pol only to pol backend (fe589cf6bc)
+-   chore(connect): rename 'getAssetByUrl' to a more apt fn name 'tryLocalAssetRequire' (f5e8f256ae)
+-   docs(connect-explorer): remove trailing commas from json excerpts (dc0147900d)
+-   refactor(transport): background sessions improved (7644107353)
+-   refactor(connect): connect error codes typing (57815188d1)
+-   chore(connect): update device authenticity config (063d68379f)
+-   docs: fix header level in connect changelog (ac53d354cc)
+-   fix(connect): add other-error to FirmwareRevisionCheckResult errors (4361aba5b7)
+
+# 9.4.2
+
+This release fixes an issue with TypeScript and certain libraries not being resolved correctly in the previous version.
+If you are still seeing issues with USB types, please add `w3c-web-usb` to your `tsconfig.json` file under `types`.
 
 ### Features
 
@@ -36,26 +81,13 @@ Use the persistent link [connect.trezor.io/9](https://connect.trezor.io/9/) to a
     -   chore(connect-explorer): improve fallback schema illustration (d0619b7)
     -   chore(connect-explorer): improve typography (f730904)
 
-# 9.4.2-beta.1
-
-### Features
-
--   feat(connect): return device info with method response (a378def)
--   docs(connect-explorer): flowchart for auto core mode (9501d3d)
--   docs(connect-explorer): diagram and explanation for core in popup (3bbb032)
-
-### Fixes
-
--   Fixing an issue with typescript not being able to resolve @sinclair/typebox and USB types correctly ((98d6437))
--   Fixing regression that made it impossible to acquire (steal) device session over webusb (5cf83b4)
--   Couple of other fixes and improvements of device handling:
-
-    -   fix(connect): pending transport event fix (231899f)
-    -   fix(connect): DeviceList create devices sequentially (b4a915b)
+### Dependencies update
 
--   fix(connect-explorer): icons on index page (fef3791)
+-   npm-release: @trezor/connect-common 0.2.2
+-   npm-release: @trezor/transport 1.3.2
+-   npm-release: @trezor/protobuf 1.2.2
 
-## 9.4.1
+# 9.4.1
 
 Automatic retry for no transport issue: If the transport (bridge) is initially not available, the automatic retry feature allows the user to continue after starting the transport, without having to restart the entire flow.
 

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.4.2-beta.2
+API version 9.4.3-beta.1
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/test-connect.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/test-connect.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)

package/lib/api/checkFirmwareAuthenticity.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
+const utils_1 = require("@trezor/utils");
 const AbstractMethod_1 = require("../core/AbstractMethod");
 const firmware_1 = require("./firmware");
 const firmwareInfo_1 = require("../data/firmwareInfo");
@@ -24,10 +25,16 @@ class CheckFirmwareAuthenticity extends AbstractMethod_1.AbstractMethod {
         }
         const btcOnly = device.firmwareType === types_1.FirmwareType.BitcoinOnly;
         try {
+            const version = device.getVersion();
+            const release = (0, firmwareInfo_1.getReleases)((_a = device.features) === null || _a === void 0 ? void 0 : _a.internal_model).find(r => version &&
+                utils_1.versionUtils.isVersionArray(version) &&
+                utils_1.versionUtils.isEqual(r.version, version));
+            if (!release) {
+                throw constants_1.ERRORS.TypedError('Runtime', 'no firmware found for this device');
+            }
             const fw = await (0, firmware_1.getBinary)({
-                releases: (0, firmwareInfo_1.getReleases)((_a = device.features) === null || _a === void 0 ? void 0 : _a.internal_model),
                 baseUrl: (_b = this.params.baseUrl) !== null && _b !== void 0 ? _b : 'https://data.trezor.io',
-                version: device.getVersion(),
+                release,
                 btcOnly,
             });
             if (!fw) {

package/lib/api/firmware/getBinary.d.ts

@@ -1,11 +1,10 @@
-import { FirmwareRelease, IntermediaryVersion } from '../../types';
+import { FirmwareRelease } from '../../types';
 interface GetBinaryProps {
     baseUrl: string;
     btcOnly?: boolean;
-    version?: number[];
-    intermediaryVersion?: IntermediaryVersion;
-    releases: FirmwareRelease[];
+    release: FirmwareRelease;
 }
-export declare const getBinary: ({ releases, baseUrl, version, btcOnly, intermediaryVersion, }: GetBinaryProps) => Promise<ArrayBuffer>;
+export declare const getBinary: ({ baseUrl, btcOnly, release }: GetBinaryProps) => Promise<ArrayBuffer>;
+export declare const getBinaryOptional: (props: GetBinaryProps) => Promise<ArrayBuffer | null>;
 export {};
 //# sourceMappingURL=getBinary.d.ts.map

package/lib/api/firmware/getBinary.js

@@ -1,21 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBinary = void 0;
-const utils_1 = require("@trezor/utils");
+exports.getBinaryOptional = exports.getBinary = void 0;
 const assets_1 = require("../../utils/assets");
-const getBinary = ({ releases, baseUrl, version, btcOnly, intermediaryVersion, }) => {
-    if (intermediaryVersion) {
-        return (0, assets_1.httpRequest)(`${baseUrl}/firmware/t1b1/trezor-t1b1-inter-v${intermediaryVersion}.bin`, 'binary');
-    }
-    const releaseByFirmware = releases.find(r => version &&
-        utils_1.versionUtils.isVersionArray(version) &&
-        utils_1.versionUtils.isEqual(r.version, version));
-    if (releaseByFirmware === undefined) {
-        throw new Error('no firmware found for this device');
-    }
-    const fwUrl = releaseByFirmware[btcOnly ? 'url_bitcoinonly' : 'url'];
+const getBinary = ({ baseUrl, btcOnly, release }) => {
+    const fwUrl = release[btcOnly ? 'url_bitcoinonly' : 'url'];
     const url = `${baseUrl}/${fwUrl}`;
     return (0, assets_1.httpRequest)(url, 'binary');
 };
 exports.getBinary = getBinary;
+const getBinaryOptional = async (props) => {
+    try {
+        return await (0, exports.getBinary)(props);
+    }
+    catch (error) {
+        return null;
+    }
+};
+exports.getBinaryOptional = getBinaryOptional;
 //# sourceMappingURL=getBinary.js.map

package/lib/api/firmware/getBinaryForFirmwareUpgrade.d.ts

@@ -1,11 +1,11 @@
 import { GetInfoProps } from '../../data/firmwareInfo';
-import { IntermediaryVersion } from '../../types';
+import { IntermediaryVersion, VersionArray } from '../../types';
 interface GetBinaryForFirmwareUpgradeProps extends GetInfoProps {
     baseUrl: string;
     btcOnly?: boolean;
-    version?: number[];
+    version?: VersionArray;
     intermediaryVersion?: IntermediaryVersion;
 }
-export declare const getBinaryForFirmwareUpgrade: ({ features, releases, baseUrl, version, btcOnly, intermediaryVersion, }: GetBinaryForFirmwareUpgradeProps) => Promise<ArrayBuffer>;
+export declare const getBinaryForFirmwareUpgrade: ({ releases, baseUrl, version, btcOnly, intermediaryVersion, features, }: GetBinaryForFirmwareUpgradeProps) => Promise<ArrayBuffer>;
 export {};
 //# sourceMappingURL=getBinaryForFirmwareUpgrade.d.ts.map

package/lib/api/firmware/getBinaryForFirmwareUpgrade.js

@@ -6,7 +6,7 @@ const assets_1 = require("../../utils/assets");
 const firmwareUtils_1 = require("../../utils/firmwareUtils");
 const firmwareInfo_1 = require("../../data/firmwareInfo");
 const getBinary_1 = require("./getBinary");
-const getBinaryForFirmwareUpgrade = ({ features, releases, baseUrl, version, btcOnly, intermediaryVersion, }) => {
+const getBinaryForFirmwareUpgrade = ({ releases, baseUrl, version, btcOnly, intermediaryVersion, features, }) => {
     if (!(0, firmwareUtils_1.isStrictFeatures)(features)) {
         throw new Error('Features of unexpected shape provided');
     }
@@ -26,7 +26,7 @@ const getBinaryForFirmwareUpgrade = ({ features, releases, baseUrl, version, btc
     if (!utils_1.versionUtils.isEqual(releaseByFirmware.version, infoByBootloader.release.version)) {
         throw new Error(`version provided as param (${releaseByFirmware.version}) does not match firmware version found by features in bootloader (${infoByBootloader.release.version})`);
     }
-    return (0, getBinary_1.getBinary)({ releases, baseUrl, version, btcOnly, intermediaryVersion });
+    return (0, getBinary_1.getBinary)({ release: releaseByFirmware, baseUrl, btcOnly });
 };
 exports.getBinaryForFirmwareUpgrade = getBinaryForFirmwareUpgrade;
 //# sourceMappingURL=getBinaryForFirmwareUpgrade.js.map

package/lib/api/firmware/index.d.ts

@@ -1,5 +1,5 @@
 export { getBinaryForFirmwareUpgrade } from './getBinaryForFirmwareUpgrade';
-export { getBinary } from './getBinary';
+export { getBinary, getBinaryOptional } from './getBinary';
 export { getLanguage } from '../../data/getLanguage';
 export { shouldStripFwHeaders, stripFwHeaders } from './modifyFirmware';
 export { uploadFirmware } from './uploadFirmware';

package/lib/api/firmware/index.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFirmwareHeaders = exports.calculateFirmwareHash = exports.uploadFirmware = exports.stripFwHeaders = exports.shouldStripFwHeaders = exports.getLanguage = exports.getBinary = exports.getBinaryForFirmwareUpgrade = void 0;
+exports.parseFirmwareHeaders = exports.calculateFirmwareHash = exports.uploadFirmware = exports.stripFwHeaders = exports.shouldStripFwHeaders = exports.getLanguage = exports.getBinaryOptional = exports.getBinary = exports.getBinaryForFirmwareUpgrade = void 0;
 var getBinaryForFirmwareUpgrade_1 = require("./getBinaryForFirmwareUpgrade");
 Object.defineProperty(exports, "getBinaryForFirmwareUpgrade", { enumerable: true, get: function () { return getBinaryForFirmwareUpgrade_1.getBinaryForFirmwareUpgrade; } });
 var getBinary_1 = require("./getBinary");
 Object.defineProperty(exports, "getBinary", { enumerable: true, get: function () { return getBinary_1.getBinary; } });
+Object.defineProperty(exports, "getBinaryOptional", { enumerable: true, get: function () { return getBinary_1.getBinaryOptional; } });
 var getLanguage_1 = require("../../data/getLanguage");
 Object.defineProperty(exports, "getLanguage", { enumerable: true, get: function () { return getLanguage_1.getLanguage; } });
 var modifyFirmware_1 = require("./modifyFirmware");

package/lib/api/resetDevice.js

@@ -14,7 +14,6 @@ class ResetDevice extends AbstractMethod_1.AbstractMethod {
         const { payload } = this;
         (0, schema_utils_1.Assert)(constants_1.PROTO.ResetDevice, payload);
         this.params = {
-            display_random: payload.display_random,
             strength: payload.strength || 256,
             passphrase_protection: payload.passphrase_protection,
             pin_protection: payload.pin_protection,

package/lib/backend/Blockchain.js

@@ -26,11 +26,8 @@ const getNormalizedTrezorShortcut = (shortcut) => {
     if (shortcut === 'tXRP') {
         return 'XRP';
     }
-    return shortcut;
-};
-const getNormalizedBackendShortcut = (shortcut) => {
-    if (shortcut.toLowerCase() === 'matic') {
-        return 'pol';
+    if (shortcut === 'OP') {
+        return 'ETH';
     }
     return shortcut;
 };
@@ -85,7 +82,7 @@ class Blockchain {
         }
         this.serverInfo = info;
         const trezorShortcut = getNormalizedTrezorShortcut(this.coinInfo.shortcut);
-        const backendShortcut = getNormalizedBackendShortcut(this.serverInfo.shortcut);
+        const backendShortcut = this.serverInfo.shortcut;
         if (trezorShortcut.toLowerCase() !== backendShortcut.toLowerCase()) {
             throw constants_1.ERRORS.TypedError('Backend_Invalid');
         }

package/lib/constants/errors.d.ts

@@ -1,46 +1,54 @@
 export declare const ERROR_CODES: {
-    Init_NotInitialized: string;
-    Init_AlreadyInitialized: string;
-    Init_IframeBlocked: string;
-    Init_IframeTimeout: string;
-    Init_ManifestMissing: string;
-    Popup_ConnectionMissing: string;
-    Transport_Missing: string;
-    Transport_InvalidProtobuf: string;
-    Method_InvalidPackage: string;
-    Method_InvalidParameter: string;
-    Method_NotAllowed: string;
-    Method_PermissionsNotGranted: string;
-    Method_Cancel: string;
-    Method_Interrupted: string;
-    Method_UnknownCoin: string;
-    Method_AddressNotMatch: string;
-    Method_FirmwareUpdate_DownloadFailed: string;
-    Method_Discovery_BundleException: string;
-    Method_Override: string;
-    Method_NoResponse: string;
-    Backend_NotSupported: string;
-    Backend_WorkerMissing: string;
-    Backend_Disconnected: string;
-    Backend_Invalid: string;
-    Backend_Error: string;
-    Runtime: string;
-    Device_NotFound: string;
-    Device_InitializeFailed: string;
-    Device_FwException: string;
-    Device_ModeException: string;
-    Device_Disconnected: string;
-    Device_UsedElsewhere: string;
-    Device_InvalidState: string;
-    Device_CallInProgress: string;
-    Device_MultipleNotSupported: string;
+    readonly Init_NotInitialized: "TrezorConnect not initialized";
+    readonly Init_AlreadyInitialized: "TrezorConnect has been already initialized";
+    readonly Init_IframeBlocked: "Iframe blocked";
+    readonly Init_IframeTimeout: "Iframe timeout";
+    readonly Init_ManifestMissing: "Manifest not set. Read more at https://github.com/trezor/trezor-suite/blob/develop/docs/packages/connect/index.md";
+    readonly Popup_ConnectionMissing: "Unable to establish connection with iframe";
+    readonly Transport_Missing: "Transport is missing";
+    readonly Transport_InvalidProtobuf: "";
+    readonly Method_InvalidPackage: "This package is not suitable to work with browser. Use @trezor/connect-web package instead";
+    readonly Method_InvalidParameter: "";
+    readonly Method_NotAllowed: "Method not allowed for this configuration";
+    readonly Method_PermissionsNotGranted: "Permissions not granted";
+    readonly Method_Cancel: "Cancelled";
+    readonly Method_Interrupted: "Popup closed";
+    readonly Method_UnknownCoin: "Coin not found";
+    readonly Method_AddressNotMatch: "Addresses do not match";
+    readonly Method_FirmwareUpdate_DownloadFailed: "Failed to download firmware binary";
+    readonly Method_Discovery_BundleException: "";
+    readonly Method_Override: "override";
+    readonly Method_NoResponse: "Call resolved without response";
+    readonly Backend_NotSupported: "BlockchainLink settings not found in coins.json";
+    readonly Backend_WorkerMissing: "";
+    readonly Backend_Disconnected: "Backend disconnected";
+    readonly Backend_Invalid: "Invalid backend";
+    readonly Backend_Error: "";
+    readonly Runtime: "";
+    readonly Device_NotFound: "Device not found";
+    readonly Device_InitializeFailed: "";
+    readonly Device_FwException: "";
+    readonly Device_ModeException: "";
+    readonly Device_Disconnected: "Device disconnected";
+    readonly Device_UsedElsewhere: "Device is used in another window";
+    readonly Device_InvalidState: "Passphrase is incorrect";
+    readonly Device_CallInProgress: "Device call in progress";
+    readonly Device_MultipleNotSupported: "Multiple devices are not supported";
+    readonly Failure_ActionCancelled: "Action cancelled by user";
+    readonly Failure_FirmwareError: "Firmware installation failed";
+    readonly Failure_UnknownCode: "Unknown error";
+    readonly Failure_PinCancelled: "PIN cancelled";
+    readonly Failure_PinMismatch: "PIN mismatch";
+    readonly Failure_WipeCodeMismatch: "Wipe code mismatch";
+    readonly Deeplink_VersionMismatch: "Not compatible with current version of the app";
 };
+export type ErrorCode = keyof typeof ERROR_CODES;
 export declare class TrezorError extends Error {
-    code: string;
+    code: ErrorCode;
     message: string;
-    constructor(code: string, message: string);
+    constructor(code: ErrorCode, message: string);
 }
-export declare const TypedError: (id: keyof typeof ERROR_CODES, message?: string) => TrezorError;
+export declare const TypedError: (id: ErrorCode, message?: string) => TrezorError;
 export declare const serializeError: (payload: any) => any;
 export declare const LIBUSB_ERROR_MESSAGE = "LIBUSB_ERROR";
 //# sourceMappingURL=errors.d.ts.map

package/lib/constants/errors.js

@@ -37,6 +37,13 @@ exports.ERROR_CODES = {
     Device_InvalidState: 'Passphrase is incorrect',
     Device_CallInProgress: 'Device call in progress',
     Device_MultipleNotSupported: 'Multiple devices are not supported',
+    Failure_ActionCancelled: 'Action cancelled by user',
+    Failure_FirmwareError: 'Firmware installation failed',
+    Failure_UnknownCode: 'Unknown error',
+    Failure_PinCancelled: 'PIN cancelled',
+    Failure_PinMismatch: 'PIN mismatch',
+    Failure_WipeCodeMismatch: 'Wipe code mismatch',
+    Deeplink_VersionMismatch: 'Not compatible with current version of the app',
 };
 class TrezorError extends Error {
     constructor(code, message) {

package/lib/constants/firmware.d.ts

@@ -0,0 +1,2 @@
+export declare const FW_HASH_SUPPORTED_VERSIONS: string[];
+//# sourceMappingURL=firmware.d.ts.map

package/lib/constants/firmware.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FW_HASH_SUPPORTED_VERSIONS = void 0;
+exports.FW_HASH_SUPPORTED_VERSIONS = ['1.11.1', '2.5.1'];
+//# sourceMappingURL=firmware.js.map

package/lib/constants/index.d.ts

@@ -2,5 +2,6 @@ export * as ERRORS from './errors';
 export * as NETWORK from './network';
 export * as CARDANO from './cardano';
 export * as NEM from './nem';
+export * as FIRMWARE from './firmware';
 export { MessagesSchema as PROTO } from '@trezor/protobuf';
 //# sourceMappingURL=index.d.ts.map

package/lib/constants/index.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROTO = exports.NEM = exports.CARDANO = exports.NETWORK = exports.ERRORS = void 0;
+exports.PROTO = exports.FIRMWARE = exports.NEM = exports.CARDANO = exports.NETWORK = exports.ERRORS = void 0;
 const tslib_1 = require("tslib");
 exports.ERRORS = tslib_1.__importStar(require("./errors"));
 exports.NETWORK = tslib_1.__importStar(require("./network"));
 exports.CARDANO = tslib_1.__importStar(require("./cardano"));
 exports.NEM = tslib_1.__importStar(require("./nem"));
+exports.FIRMWARE = tslib_1.__importStar(require("./firmware"));
 var protobuf_1 = require("@trezor/protobuf");
 Object.defineProperty(exports, "PROTO", { enumerable: true, get: function () { return protobuf_1.MessagesSchema; } });
 //# sourceMappingURL=index.js.map

package/lib/core/onCallFirmwareUpdate.js

@@ -255,7 +255,7 @@ const onCallFirmwareUpdate = async ({ params, context: { deviceList, postMessage
             log.error('onCallFirmwareUpdate', 'changeLanguage failed silently: ', err);
         }
     }
-    const checkSupported = reconnectedDevice.atLeast(['1.11.1', '2.5.1']) && !params.binary;
+    const checkSupported = reconnectedDevice.atLeast(constants_1.FIRMWARE.FW_HASH_SUPPORTED_VERSIONS) && !params.binary;
     if (checkSupported) {
         try {
             log.debug('onCallFirmwareUpdate', 'getFirmwareHash supported, proceed with check', stripped);

package/lib/data/analyticsInfo.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enhanceMessageWithAnalytics = void 0;
+const connect_analytics_1 = require("@trezor/connect-analytics");
 const events_1 = require("../events");
 const enhanceMessageWithAnalytics = (message, data) => {
     var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -12,7 +13,7 @@ const enhanceMessageWithAnalytics = (message, data) => {
                 payload: {
                     ...message.payload,
                     analytics: {
-                        type: 'device/selected',
+                        type: connect_analytics_1.EventType.DeviceSelected,
                         payload: {
                             mode: (device === null || device === void 0 ? void 0 : device.mode) || '',
                             pinProtection: ((_a = device === null || device === void 0 ? void 0 : device.features) === null || _a === void 0 ? void 0 : _a.pin_protection) || '',

package/lib/data/connectSettings.js

@@ -21,6 +21,7 @@ const initialSettings = {
     timestamp: new Date().getTime(),
     interactionTimeout: 600,
     sharedLogger: true,
+    deeplinkUrl: `${version_1.DEFAULT_DOMAIN}deeplink/${version_1.DEEPLINK_VERSION}/`,
 };
 const parseManifest = (manifest) => {
     if (!manifest)
@@ -71,6 +72,7 @@ const parseConnectSettings = (input = {}) => {
     settings.iframeSrc = `${src}iframe.html`;
     settings.popupSrc = `${src}popup.html`;
     settings.webusbSrc = `${src}webusb.html`;
+    settings.deeplinkUrl = `${src}deeplink/${version_1.DEEPLINK_VERSION}/`;
     if (typeof input.transportReconnect === 'boolean') {
         settings.transportReconnect = input.transportReconnect;
     }
@@ -117,6 +119,9 @@ const parseConnectSettings = (input = {}) => {
     if (typeof input._sessionsBackgroundUrl === 'string') {
         settings._sessionsBackgroundUrl = input._sessionsBackgroundUrl;
     }
+    if (typeof input.binFilesBaseUrl === 'string') {
+        settings.binFilesBaseUrl = input.binFilesBaseUrl;
+    }
     return settings;
 };
 exports.parseConnectSettings = parseConnectSettings;

package/lib/data/deviceAuthenticityConfig.js

@@ -92,6 +92,9 @@ exports.deviceAuthenticityConfig = {
             '04903be00e4c5561413513eec337f0a6bec4968711de83242856e6b2bf1f06b26732b7bb1322a817448c03fc2f312318af67be580add0768179ce1af1f5e777bd0',
             '0464f0ef96854bc7f081396ce7a2c75df4208f551c19d27f5a81238d47b842df800383a736a1b5b1c9e1e458d05ea1584e12278ab5e1252a098820251b37917c22',
             '0401f3f804333b4d0caa18d27dfc0698dbc11c33b703019018e5819734ef2551615ba6915e6119bd7d36c035553ea660f1ccf7c34e2375e8e1ddf0a471b76707fd',
+            '04b427eb0e1484b7127f82820edddbbb538c11d3c330b5f68acef96c8cf4601b30390311f2d48090f3f5c5e4bf56ca0396984797cd92ab0d12164600c9f43d2ba3',
+            '0438e670e9eb3cd19f8579b3202caf9aa766c8d5735ab97bd3682155437499e062587bded86c732789345538581c83e9e42af0a15a4ad81bc42e1f28a7859ebce0',
+            '04ac2a7e88ffc08186b3cb461966a96cacdb2c07b383018d708a6f0ce0b74f59dca97a6f31fc8d243a781c7fe5006dc6b8ef05347972082b32fb29c636c595ffbc',
         ],
         debug: {
             rootPubKeys: [

package/lib/data/version.d.ts

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

package/lib/data/version.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTENT_SCRIPT_VERSION = exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.4.2-beta.2';
+exports.DEEPLINK_VERSION = exports.CONTENT_SCRIPT_VERSION = exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
+exports.VERSION = '9.4.3-beta.1';
 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;
+exports.DEEPLINK_VERSION = 1;
 //# sourceMappingURL=version.js.map

package/lib/device/Device.d.ts

@@ -5,7 +5,7 @@ import { DeviceCommands } from './DeviceCommands';
 import { PROTO, NETWORK } from '../constants';
 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 { Device as DeviceTyped, DeviceFirmwareStatus, DeviceState, Features, ReleaseInfo, UnavailableCapabilities, FirmwareType, VersionArray, KnownDevice, FirmwareHashCheckResult } from '../types';
 import { IStateStorage } from './StateStorage';
 import type { PromptCallback } from './prompts';
 export type RunOptions = {
@@ -78,6 +78,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     initialize(useCardanoDerivation: boolean): Promise<void>;
     initStorage(storage: IStateStorage): void;
     getFeatures(): Promise<void>;
+    checkFirmwareHash(): Promise<FirmwareHashCheckResult | null>;
     checkFirmwareRevision(): Promise<void>;
     changeLanguage({ language, binary, }: {
         language?: undefined;

package/lib/device/Device.js

@@ -16,6 +16,8 @@ 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 crypto_1 = require("crypto");
 const _log = (0, debug_1.initLog)('Device');
 exports.GET_FEATURES_TIMEOUT = 3000;
 exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
@@ -40,6 +42,7 @@ class Device extends utils_1.TypedEmitter {
         this.availableTranslations = [];
         this.authenticityChecks = {
             firmwareRevision: null,
+            firmwareHash: null,
         };
         this.useCardanoDerivation = false;
         this.protocol = protocol_1.v1;
@@ -321,9 +324,12 @@ class Device extends utils_1.TypedEmitter {
     async getFeatures() {
         const { message } = await this.getCommands().typedCall('GetFeatures', 'Features', {});
         this._updateFeatures(message);
+        if (this.authenticityChecks.firmwareHash === null) {
+            this.authenticityChecks.firmwareHash = await this.checkFirmwareHash();
+        }
         if (this.authenticityChecks.firmwareRevision === null ||
             (this.authenticityChecks.firmwareRevision.success === false &&
-                this.authenticityChecks.firmwareRevision.error === 'cannot-perform-check-offline')) {
+                ['cannot-perform-check-offline', 'other-error'].includes(this.authenticityChecks.firmwareRevision.error))) {
             await this.checkFirmwareRevision();
         }
         if (!this.features.language_version_matches &&
@@ -338,6 +344,47 @@ class Device extends utils_1.TypedEmitter {
             }
         }
     }
+    async checkFirmwareHash() {
+        var _a;
+        const createFailResult = (error) => ({ success: false, error });
+        const firmwareVersion = this.getVersion();
+        if (firmwareVersion === undefined || !this.features || this.features.bootloader_mode) {
+            return null;
+        }
+        const baseUrl = DataManager_1.DataManager.getSettings('binFilesBaseUrl');
+        const isModelOne = this.features.internal_model === types_1.DeviceModelInternal.T1B1;
+        if (baseUrl === undefined || !isModelOne)
+            return createFailResult('check-skipped');
+        const checkSupported = this.atLeast(constants_1.FIRMWARE.FW_HASH_SUPPORTED_VERSIONS);
+        if (!checkSupported)
+            return createFailResult('check-unsupported');
+        const release = (0, firmwareInfo_1.getReleases)(this.features.internal_model).find(r => utils_1.versionUtils.isEqual(r.version, firmwareVersion));
+        if (release === undefined)
+            return createFailResult('unknown-release');
+        const btcOnly = this.firmwareType === types_1.FirmwareType.BitcoinOnly;
+        const binary = await (0, firmware_1.getBinaryOptional)({ baseUrl, btcOnly, release });
+        if (binary === null) {
+            return createFailResult('check-unsupported');
+        }
+        const strippedBinary = (0, firmware_1.stripFwHeaders)(binary);
+        const { hash: expectedHash, challenge } = (0, firmware_1.calculateFirmwareHash)(this.features.major_version, strippedBinary, (0, crypto_1.randomBytes)(32));
+        const getFirmwareHashOptional = async () => {
+            try {
+                return await this.getCommands().typedCall('GetFirmwareHash', 'FirmwareHash', {
+                    challenge,
+                });
+            }
+            catch (e) {
+                return null;
+            }
+        };
+        const deviceResponse = await getFirmwareHashOptional();
+        if (!((_a = deviceResponse === null || deviceResponse === void 0 ? void 0 : deviceResponse.message) === null || _a === void 0 ? void 0 : _a.hash))
+            return createFailResult('other-error');
+        if (deviceResponse.message.hash !== expectedHash)
+            return createFailResult('hash-mismatch');
+        return { success: true };
+    }
     async checkFirmwareRevision() {
         const firmwareVersion = this.getVersion();
         if (!firmwareVersion || !this.features) {
@@ -567,21 +614,25 @@ class Device extends utils_1.TypedEmitter {
     }
     toMessageObject() {
         var _a;
+        const { path } = this.originalDescriptor;
+        const { name } = this;
+        const base = {
+            path,
+            name,
+        };
         if (this.unreadableError) {
             return {
+                ...base,
                 type: 'unreadable',
-                path: this.originalDescriptor.path,
                 error: this.unreadableError,
                 label: 'Unreadable device',
-                name: this.name,
             };
         }
         if (this.isUnacquired()) {
             return {
+                ...base,
                 type: 'unacquired',
-                path: this.originalDescriptor.path,
                 label: 'Unacquired device',
-                name: this.name,
             };
         }
         const defaultLabel = 'My Trezor';
@@ -590,15 +641,14 @@ class Device extends utils_1.TypedEmitter {
         if (this.featuresNeedsReload)
             status = 'used';
         return {
+            ...base,
             type: 'acquired',
             id: this.features.device_id,
-            path: this.originalDescriptor.path,
             label,
             _state: this.getState(),
             state: (_a = this.getState()) === null || _a === void 0 ? void 0 : _a.staticSessionId,
             status,
             mode: this.getMode(),
-            name: this.name,
             color: this.color,
             firmware: this.firmwareStatus,
             firmwareRelease: this.firmwareRelease,

package/lib/device/checkFirmwareRevision.js

@@ -42,10 +42,10 @@ const checkFirmwareRevision = async ({ firmwareVersion, internalModel, deviceRev
             return { success: true };
         }
         catch (e) {
-            return {
-                success: false,
-                error: 'cannot-perform-check-offline',
-            };
+            if (e.name === 'FetchError' && e.code === 'ENOTFOUND') {
+                return failFirmwareRevisionCheck('cannot-perform-check-offline');
+            }
+            return failFirmwareRevisionCheck('other-error');
         }
     }
     if (!doRevisionsMatch({

package/lib/events/core.d.ts

@@ -7,6 +7,7 @@ import type { TransportEventMessage, TransportDisableWebUSB, TransportRequestWeb
 import type { UiEventMessage } from './ui-request';
 import type { UiResponseEvent } from './ui-response';
 import type { Unsuccessful } from '../types/params';
+import { ErrorCode, TrezorError } from '../constants/errors';
 export declare const CORE_EVENT = "CORE_EVENT";
 export type CoreRequestMessage = PopupClosedMessage | PopupAnalyticsResponse | TransportDisableWebUSB | TransportRequestWebUSBDevice | TransportGetInfo | UiResponseEvent | IFrameInit | IFrameCallMessage | IFrameLogRequest;
 export type CoreEventMessage = {
@@ -17,7 +18,7 @@ export type CoreEventMessage = {
     };
 } & (BlockchainEventMessage | DeviceEventMessage | TransportEventMessage | UiEventMessage | MethodResponseMessage | IFrameEventMessage | PopupEventMessage);
 export declare const parseMessage: <T extends CoreRequestMessage | CoreEventMessage = never>(messageData: any) => T;
-export declare const createErrorMessage: (error: Error & {
-    code?: string;
-}) => Unsuccessful;
+export declare const createErrorMessage: (error: (Error & {
+    code?: ErrorCode;
+}) | TrezorError) => Unsuccessful;
 //# sourceMappingURL=core.d.ts.map

package/lib/impl/dynamic.d.ts

@@ -0,0 +1,39 @@
+import EventEmitter from 'events';
+import { ConnectFactoryDependencies } from '../factory';
+import type { ConnectSettingsPublic, Manifest } from '../types';
+import { CallMethodPayload } from '../events';
+type TrezorConnectDynamicParams<TrezorConnectImplType> = {
+    implementations: {
+        type: TrezorConnectImplType;
+        impl: ConnectFactoryDependencies;
+    }[];
+    getInitTarget: (settings: Partial<ConnectSettingsPublic>) => TrezorConnectImplType;
+    handleErrorFallback: (errorCode: string) => Promise<boolean>;
+};
+export declare class TrezorConnectDynamic<TrezorConnectImplType> implements ConnectFactoryDependencies {
+    eventEmitter: EventEmitter;
+    private currentTarget;
+    private implementations;
+    private getInitTarget;
+    private handleErrorFallback;
+    lastSettings?: {
+        manifest: Manifest;
+    } & Partial<ConnectSettingsPublic>;
+    constructor({ implementations, getInitTarget, handleErrorFallback, }: TrezorConnectDynamicParams<TrezorConnectImplType>);
+    private getTarget;
+    switchTarget(target: TrezorConnectImplType): Promise<void>;
+    manifest(manifest: Manifest): void;
+    init(settings: {
+        manifest: Manifest;
+    } & Partial<ConnectSettingsPublic>): Promise<void>;
+    call(params: CallMethodPayload): Promise<any>;
+    requestLogin(params: any): import("../types").Response<import("../types/api/requestLogin").Login>;
+    uiResponse(params: any): void;
+    renderWebUSBButton(): void;
+    disableWebUSB(): void;
+    requestWebUSBDevice(): void;
+    cancel(error?: string): void;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=dynamic.d.ts.map

package/lib/impl/dynamic.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrezorConnectDynamic = void 0;
+const constants_1 = require("../constants");
+const proxy_event_emitter_1 = require("../utils/proxy-event-emitter");
+class TrezorConnectDynamic {
+    constructor({ implementations, getInitTarget, handleErrorFallback, }) {
+        this.implementations = implementations;
+        this.currentTarget = this.implementations[0].type;
+        this.getInitTarget = getInitTarget;
+        this.handleErrorFallback = handleErrorFallback;
+        this.eventEmitter = new proxy_event_emitter_1.ProxyEventEmitter(this.implementations.map(impl => impl.impl.eventEmitter));
+    }
+    getTarget() {
+        return this.implementations.find(impl => impl.type === this.currentTarget).impl;
+    }
+    async switchTarget(target) {
+        if (this.currentTarget === target) {
+            return;
+        }
+        if (!this.lastSettings) {
+            throw constants_1.ERRORS.TypedError('Init_NotInitialized');
+        }
+        await this.getTarget().dispose();
+        this.currentTarget = target;
+        await this.getTarget().init(this.lastSettings);
+    }
+    manifest(manifest) {
+        this.lastSettings = {
+            ...this.lastSettings,
+            manifest,
+        };
+        this.getTarget().manifest(manifest);
+    }
+    async init(settings) {
+        if (!(settings === null || settings === void 0 ? void 0 : settings.manifest)) {
+            throw constants_1.ERRORS.TypedError('Init_ManifestMissing');
+        }
+        this.lastSettings = settings;
+        this.currentTarget = this.getInitTarget(settings);
+        try {
+            return await this.getTarget().init(this.lastSettings);
+        }
+        catch (error) {
+            if (await this.handleErrorFallback(error.code)) {
+                return await this.getTarget().init(settings);
+            }
+            throw error;
+        }
+    }
+    async call(params) {
+        const response = await this.getTarget().call(params);
+        if (!response.success) {
+            if (await this.handleErrorFallback(response.payload.code)) {
+                return await this.getTarget().call(params);
+            }
+        }
+        return response;
+    }
+    requestLogin(params) {
+        return this.getTarget().requestLogin(params);
+    }
+    uiResponse(params) {
+        return this.getTarget().uiResponse(params);
+    }
+    renderWebUSBButton() {
+        return this.getTarget().renderWebUSBButton();
+    }
+    disableWebUSB() {
+        return this.getTarget().disableWebUSB();
+    }
+    requestWebUSBDevice() {
+        return this.getTarget().requestWebUSBDevice();
+    }
+    cancel(error) {
+        return this.getTarget().cancel(error);
+    }
+    dispose() {
+        this.eventEmitter.removeAllListeners();
+        return this.getTarget().dispose();
+    }
+}
+exports.TrezorConnectDynamic = TrezorConnectDynamic;
+//# sourceMappingURL=dynamic.js.map

package/lib/types/device.d.ts

@@ -16,22 +16,32 @@ export type DeviceState = {
 export type UnavailableCapabilities = {
     [key: string]: UnavailableCapability;
 };
+export type FirmwareRevisionCheckError = 'revision-mismatch' | 'firmware-version-unknown' | 'cannot-perform-check-offline' | 'other-error';
 export type FirmwareRevisionCheckResult = {
     success: true;
 } | {
     success: false;
-    error: 'revision-mismatch' | 'firmware-version-unknown' | 'firmware-version-unknown' | 'cannot-perform-check-offline';
+    error: FirmwareRevisionCheckError;
 };
-export type KnownDevice = {
+export type FirmwareHashCheckError = 'hash-mismatch' | 'check-skipped' | 'check-unsupported' | 'unknown-release' | 'other-error';
+export type FirmwareHashCheckResult = {
+    success: true;
+} | {
+    success: false;
+    error: FirmwareHashCheckError;
+};
+type BaseDevice = {
+    path: string;
+    name: string;
+};
+export type KnownDevice = BaseDevice & {
     type: 'acquired';
     id: string | null;
-    path: string;
     label: string;
     error?: typeof undefined;
     firmware: DeviceFirmwareStatus;
     firmwareRelease?: ReleaseInfo | null;
     firmwareType?: FirmwareType;
-    name: string;
     color?: string;
     status: DeviceStatus;
     mode: DeviceMode;
@@ -42,19 +52,18 @@ export type KnownDevice = {
     availableTranslations: string[];
     authenticityChecks?: {
         firmwareRevision: FirmwareRevisionCheckResult | null;
+        firmwareHash: FirmwareHashCheckResult | null;
     };
 };
-export type UnknownDevice = {
+export type UnknownDevice = BaseDevice & {
     type: 'unacquired';
-    id?: null;
-    path: string;
-    label: string;
+    label: 'Unacquired device';
+    id?: typeof undefined;
     error?: typeof undefined;
     features?: typeof undefined;
     firmware?: typeof undefined;
     firmwareRelease?: typeof undefined;
     firmwareType?: typeof undefined;
-    name: string;
     color?: typeof undefined;
     status?: typeof undefined;
     mode?: typeof undefined;
@@ -63,17 +72,15 @@ export type UnknownDevice = {
     unavailableCapabilities?: typeof undefined;
     availableTranslations?: typeof undefined;
 };
-export type UnreadableDevice = {
+export type UnreadableDevice = BaseDevice & {
     type: 'unreadable';
-    id?: null;
-    path: string;
-    label: string;
+    label: 'Unreadable device';
     error: string;
+    id?: typeof undefined;
     features?: typeof undefined;
     firmware?: typeof undefined;
     firmwareRelease?: typeof undefined;
     firmwareType?: typeof undefined;
-    name: string;
     color?: typeof undefined;
     status?: typeof undefined;
     mode?: typeof undefined;

package/lib/types/params.d.ts

@@ -1,5 +1,6 @@
 import { TSchema, Static } from '@trezor/schema-utils';
 import { DeviceState } from './device';
+import { ErrorCode } from '../constants/errors';
 export interface DeviceIdentity {
     path?: string;
     state?: string | DeviceState;
@@ -34,7 +35,7 @@ export interface Unsuccessful {
     success: false;
     payload: {
         error: string;
-        code?: string;
+        code?: ErrorCode;
     };
 }
 export interface Success<T> {

package/lib/types/settings.d.ts

@@ -25,7 +25,7 @@ export interface ConnectSettingsPublic {
     _sessionsBackgroundUrl?: string;
     deeplinkOpen?: (url: string) => void;
     deeplinkCallbackUrl?: string;
-    deeplinkUrl?: string;
+    binFilesBaseUrl?: string;
 }
 export interface ConnectSettingsInternal {
     origin?: string;
@@ -41,6 +41,7 @@ export interface ConnectSettingsInternal {
     proxy?: Proxy;
     sharedLogger?: boolean;
     useCoreInPopup?: boolean;
+    deeplinkUrl: string;
 }
 export type ConnectSettings = ConnectSettingsPublic & ConnectSettingsInternal;
 //# sourceMappingURL=settings.d.ts.map

package/lib/utils/assetUtils.d.ts

@@ -1,2 +1,2 @@
-export declare const getAssetByUrl: (url: string) => any;
+export declare const tryLocalAssetRequire: (url: string) => any;
 //# sourceMappingURL=assetUtils.d.ts.map

package/lib/utils/assetUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAssetByUrl = void 0;
+exports.tryLocalAssetRequire = void 0;
 const types_1 = require("../types");
 const isDeviceModel = (model) => {
     return Object.values(types_1.DeviceModelInternal).includes(model);
@@ -12,7 +12,7 @@ const firmwareAssets = {
     [types_1.DeviceModelInternal.T3B1]: require('@trezor/connect-common/files/firmware/t3b1/releases.json'),
     [types_1.DeviceModelInternal.T3T1]: require('@trezor/connect-common/files/firmware/t3t1/releases.json'),
 };
-const getAssetByUrl = (url) => {
+const tryLocalAssetRequire = (url) => {
     const fileUrl = url.split('?')[0];
     switch (fileUrl) {
         case './data/coins.json':
@@ -33,5 +33,5 @@ const getAssetByUrl = (url) => {
     }
     return null;
 };
-exports.getAssetByUrl = getAssetByUrl;
+exports.tryLocalAssetRequire = tryLocalAssetRequire;
 //# sourceMappingURL=assetUtils.js.map

package/lib/utils/assets.js

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

package/lib/utils/assets.native.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.httpRequest = void 0;
 const assetUtils_1 = require("./assetUtils");
-const httpRequest = (url, _type) => (0, assetUtils_1.getAssetByUrl)(url);
+const httpRequest = (url, _type) => (0, assetUtils_1.tryLocalAssetRequire)(url);
 exports.httpRequest = httpRequest;
 //# sourceMappingURL=assets.native.js.map

package/lib/utils/proxy-event-emitter.d.ts

@@ -0,0 +1,21 @@
+import EventEmitter from 'events';
+export declare class ProxyEventEmitter implements EventEmitter {
+    private eventEmitters;
+    constructor(eventEmitters: EventEmitter[]);
+    emit(eventName: string | symbol, ...args: any[]): boolean;
+    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    removeAllListeners(event?: string | symbol | undefined): this;
+    removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    setMaxListeners(n: number): this;
+    eventNames(): (string | symbol)[];
+    getMaxListeners(): number;
+    listenerCount(eventName: string | symbol, listener?: FunctionConstructor | undefined): number;
+    rawListeners(eventName: string | symbol): Function[];
+    listeners(eventName: string | symbol): Function[];
+}
+//# sourceMappingURL=proxy-event-emitter.d.ts.map

package/lib/utils/proxy-event-emitter.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyEventEmitter = void 0;
+class ProxyEventEmitter {
+    constructor(eventEmitters) {
+        this.eventEmitters = eventEmitters;
+    }
+    emit(eventName, ...args) {
+        this.eventEmitters.forEach(emitter => emitter.emit(eventName, ...args));
+        return true;
+    }
+    on(eventName, listener) {
+        this.eventEmitters.forEach(emitter => emitter.on(eventName, listener));
+        return this;
+    }
+    off(eventName, listener) {
+        this.eventEmitters.forEach(emitter => emitter.off(eventName, listener));
+        return this;
+    }
+    once(eventName, listener) {
+        this.eventEmitters.forEach(emitter => emitter.once(eventName, listener));
+        return this;
+    }
+    addListener(eventName, listener) {
+        this.eventEmitters.forEach(emitter => emitter.addListener(eventName, listener));
+        return this;
+    }
+    prependListener(eventName, listener) {
+        this.eventEmitters.forEach(emitter => emitter.prependListener(eventName, listener));
+        return this;
+    }
+    prependOnceListener(eventName, listener) {
+        this.eventEmitters.forEach(emitter => emitter.prependOnceListener(eventName, listener));
+        return this;
+    }
+    removeAllListeners(event) {
+        this.eventEmitters.forEach(emitter => emitter.removeAllListeners(event));
+        return this;
+    }
+    removeListener(eventName, listener) {
+        this.eventEmitters.forEach(emitter => emitter.removeListener(eventName, listener));
+        return this;
+    }
+    setMaxListeners(n) {
+        this.eventEmitters.forEach(emitter => emitter.setMaxListeners(n));
+        return this;
+    }
+    eventNames() {
+        return this.eventEmitters[0].eventNames();
+    }
+    getMaxListeners() {
+        return this.eventEmitters[0].getMaxListeners();
+    }
+    listenerCount(eventName, listener) {
+        return this.eventEmitters[0].listenerCount(eventName, listener);
+    }
+    rawListeners(eventName) {
+        return this.eventEmitters[0].rawListeners(eventName);
+    }
+    listeners(eventName) {
+        return this.eventEmitters[0].listeners(eventName);
+    }
+}
+exports.ProxyEventEmitter = ProxyEventEmitter;
+//# sourceMappingURL=proxy-event-emitter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.4.2-beta.2",
+  "version": "9.4.3-beta.1",
   "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.",
@@ -73,15 +73,15 @@
     "@ethereumjs/common": "^4.3.0",
     "@ethereumjs/tx": "^5.3.0",
     "@fivebinaries/coin-selection": "2.2.1",
-    "@trezor/blockchain-link": "2.3.1",
-    "@trezor/blockchain-link-types": "1.2.1",
+    "@trezor/blockchain-link": "2.3.2-beta.1",
+    "@trezor/blockchain-link-types": "1.2.2-beta.1",
     "@trezor/connect-analytics": "1.2.1",
-    "@trezor/connect-common": "0.2.2-beta.1",
-    "@trezor/protobuf": "1.2.2-beta.1",
+    "@trezor/connect-common": "0.2.3-beta.1",
+    "@trezor/protobuf": "1.2.3-beta.1",
     "@trezor/protocol": "1.2.1",
     "@trezor/schema-utils": "1.2.1",
-    "@trezor/transport": "1.3.2-beta.1",
-    "@trezor/utils": "9.2.1",
+    "@trezor/transport": "1.3.3-beta.1",
+    "@trezor/utils": "9.2.2-beta.1",
     "@trezor/utxo-lib": "2.2.1",
     "blakejs": "^1.2.1",
     "bs58": "^6.0.0",