@trezor/connect 9.4.2 → 9.4.3-beta.2

package/lib/types/device.d.ts

@@ -1,3 +1,4 @@
+import { Descriptor } from '@trezor/transport';
 import type { PROTO } from '../constants';
 import type { ReleaseInfo } from './firmware';
 export type DeviceStatus = 'available' | 'occupied' | 'used';
@@ -12,26 +13,41 @@ export type StaticSessionId = `${string}@${string}:${number}`;
 export type DeviceState = {
     sessionId?: string;
     staticSessionId?: StaticSessionId;
+    deriveCardano?: boolean;
 };
 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;
+};
+export type DeviceUniquePath = string & {
+    __type: 'DeviceUniquePath';
+};
+export declare const DeviceUniquePath: (id: string) => DeviceUniquePath;
+type BaseDevice = {
+    path: DeviceUniquePath;
+    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 +58,20 @@ export type KnownDevice = {
     availableTranslations: string[];
     authenticityChecks?: {
         firmwareRevision: FirmwareRevisionCheckResult | null;
+        firmwareHash: FirmwareHashCheckResult | null;
     };
+    transportSessionOwner?: undefined;
+    transportDescriptorType?: typeof undefined;
 };
-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;
@@ -62,18 +79,18 @@ export type UnknownDevice = {
     state?: typeof undefined;
     unavailableCapabilities?: typeof undefined;
     availableTranslations?: typeof undefined;
+    transportSessionOwner?: string;
+    transportDescriptorType?: 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;
@@ -81,6 +98,8 @@ export type UnreadableDevice = {
     state?: typeof undefined;
     unavailableCapabilities?: typeof undefined;
     availableTranslations?: typeof undefined;
+    transportSessionOwner?: undefined;
+    transportDescriptorType: Descriptor['type'];
 };
 export type Device = KnownDevice | UnknownDevice | UnreadableDevice;
 export type Features = PROTO.Features;

package/lib/types/device.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceModelInternal = exports.FirmwareType = void 0;
+exports.DeviceModelInternal = exports.DeviceUniquePath = exports.FirmwareType = void 0;
 var FirmwareType;
 (function (FirmwareType) {
     FirmwareType["BitcoinOnly"] = "bitcoin-only";
     FirmwareType["Regular"] = "regular";
 })(FirmwareType || (exports.FirmwareType = FirmwareType = {}));
+const DeviceUniquePath = (id) => id;
+exports.DeviceUniquePath = DeviceUniquePath;
 var protobuf_1 = require("@trezor/protobuf");
 Object.defineProperty(exports, "DeviceModelInternal", { enumerable: true, get: function () { return protobuf_1.DeviceModelInternal; } });
 //# sourceMappingURL=device.js.map

package/lib/types/fees.d.ts

@@ -1,30 +1,30 @@
 import { Static } from '@trezor/schema-utils';
 export type FeeInfo = Static<typeof FeeInfo>;
 export declare const FeeInfo: import("@trezor/schema-utils").TObject<{
-    blockTime: import("@sinclair/typebox").TNumber;
-    minFee: import("@sinclair/typebox").TNumber;
-    maxFee: import("@sinclair/typebox").TNumber;
-    dustLimit: import("@sinclair/typebox").TNumber;
+    blockTime: import("@trezor/schema-utils").TNumber;
+    minFee: import("@trezor/schema-utils").TNumber;
+    maxFee: import("@trezor/schema-utils").TNumber;
+    dustLimit: import("@trezor/schema-utils").TNumber;
 }>;
 export type FeeLevel = Static<typeof FeeLevel>;
 export declare const FeeLevel: import("@trezor/schema-utils").TObject<{
-    label: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"normal">, import("@sinclair/typebox").TLiteral<"economy">, import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"custom">]>;
-    feePerUnit: import("@sinclair/typebox").TString;
-    blocks: import("@sinclair/typebox").TNumber;
-    feeLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    feePerTx: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    label: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"high">, import("@trezor/schema-utils").TLiteral<"normal">, import("@trezor/schema-utils").TLiteral<"economy">, import("@trezor/schema-utils").TLiteral<"low">, import("@trezor/schema-utils").TLiteral<"custom">]>;
+    feePerUnit: import("@trezor/schema-utils").TString;
+    blocks: import("@trezor/schema-utils").TNumber;
+    feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
 }>;
 export type SelectFeeLevel = Static<typeof SelectFeeLevel>;
-export declare const SelectFeeLevel: import("@sinclair/typebox").TUnion<[import("@trezor/schema-utils").TObject<{
-    name: import("@sinclair/typebox").TString;
-    fee: import("@sinclair/typebox").TLiteral<"0">;
-    feePerByte: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
-    disabled: import("@sinclair/typebox").TLiteral<true>;
+export declare const SelectFeeLevel: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{
+    name: import("@trezor/schema-utils").TString;
+    fee: import("@trezor/schema-utils").TLiteral<"0">;
+    feePerByte: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+    disabled: import("@trezor/schema-utils").TLiteral<true>;
 }>, import("@trezor/schema-utils").TObject<{
-    name: import("@sinclair/typebox").TString;
-    fee: import("@sinclair/typebox").TString;
-    feePerByte: import("@sinclair/typebox").TString;
-    minutes: import("@sinclair/typebox").TNumber;
-    total: import("@sinclair/typebox").TString;
+    name: import("@trezor/schema-utils").TString;
+    fee: import("@trezor/schema-utils").TString;
+    feePerByte: import("@trezor/schema-utils").TString;
+    minutes: import("@trezor/schema-utils").TNumber;
+    total: import("@trezor/schema-utils").TString;
 }>]>;
 //# sourceMappingURL=fees.d.ts.map

package/lib/types/firmware.d.ts

@@ -21,7 +21,7 @@ export type FirmwareRelease = {
     translations?: string[];
 };
 export type IntermediaryVersion = 1 | 2 | 3;
-export declare const IntermediaryVersion: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<1>, import("@sinclair/typebox").TLiteral<2>, import("@sinclair/typebox").TLiteral<3>]>;
+export declare const IntermediaryVersion: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<1>, import("@trezor/schema-utils").TLiteral<2>, import("@trezor/schema-utils").TLiteral<3>]>;
 export type ReleaseInfo = {
     changelog: FirmwareRelease[] | null;
     release: FirmwareRelease;

package/lib/types/params.d.ts

@@ -1,12 +1,15 @@
 import { TSchema, Static } from '@trezor/schema-utils';
-import { DeviceState } from './device';
+import { DeviceState, DeviceUniquePath } from './device';
+import { ErrorCode } from '../constants/errors';
 export interface DeviceIdentity {
-    path?: string;
-    state?: string | DeviceState;
+    path?: DeviceUniquePath;
+    state?: DeviceState;
     instance?: number;
 }
 export interface CommonParams {
-    device?: DeviceIdentity;
+    device?: DeviceIdentity & {
+        state?: DeviceState | string;
+    };
     useEmptyPassphrase?: boolean;
     useEventListener?: boolean;
     allowSeedlessDevice?: boolean;
@@ -15,6 +18,7 @@ export interface CommonParams {
     skipFinalReload?: boolean;
     useCardanoDerivation?: boolean;
     chunkify?: boolean;
+    __info?: boolean;
 }
 export type Params<T> = CommonParams & T & {
     bundle?: undefined;
@@ -23,7 +27,7 @@ interface Bundle<T> {
     bundle: T[];
 }
 export declare const Bundle: <T extends TSchema>(type: T) => import("@trezor/schema-utils").TObject<{
-    bundle: import("@sinclair/typebox").TArray<T>;
+    bundle: import("@trezor/schema-utils").TArray<T>;
 }>;
 export type BundledParams<T> = CommonParams & Bundle<T>;
 export interface CommonParamsWithCoin extends CommonParams {
@@ -34,7 +38,7 @@ export interface Unsuccessful {
     success: false;
     payload: {
         error: string;
-        code?: string;
+        code?: ErrorCode;
     };
 }
 export interface Success<T> {
@@ -46,7 +50,7 @@ export interface SuccessWithDevice<T> extends Success<T> {
 }
 export type Response<T> = Promise<SuccessWithDevice<T> | Unsuccessful>;
 export type DerivationPath = string | number[];
-export declare const DerivationPath: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
+export declare const DerivationPath: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
 type ProtoWithExtendedAddressN<T, A, R> = Omit<Extract<T, {
     address_n: A;
 }>, 'address_n'> & {
@@ -59,11 +63,11 @@ export type ProtoWithDerivationPath<T> = ProtoWithoutAddressN<T, number[]> | Pro
 export type ProtoWithAddressN<P extends ProtoWithDerivationPath<any>> = P extends ProtoWithDerivationPath<infer T> ? T : unknown;
 export type GetAddress = Static<typeof GetAddress>;
 export declare const GetAddress: import("@trezor/schema-utils").TObject<{
-    path: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
-    address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    showOnTrezor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    chunkify: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    useEventListener: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    path: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
+    address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    showOnTrezor: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    chunkify: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    useEventListener: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;
 export interface Address {
     address: string;
@@ -72,16 +76,16 @@ export interface Address {
 }
 export type GetPublicKey = Static<typeof GetPublicKey>;
 export declare const GetPublicKey: import("@trezor/schema-utils").TObject<{
-    path: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
-    showOnTrezor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    suppressBackupWarning: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    chunkify: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    path: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
+    showOnTrezor: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    suppressBackupWarning: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    chunkify: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;
 export type PublicKey = Static<typeof PublicKey>;
 export declare const PublicKey: import("@trezor/schema-utils").TObject<{
-    publicKey: import("@sinclair/typebox").TString;
-    path: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
-    serializedPath: import("@sinclair/typebox").TString;
+    publicKey: import("@trezor/schema-utils").TString;
+    path: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+    serializedPath: import("@trezor/schema-utils").TString;
 }>;
 export {};
 //# sourceMappingURL=params.d.ts.map

package/lib/types/settings.d.ts

@@ -10,22 +10,16 @@ export interface ConnectSettingsPublic {
     manifest?: Manifest;
     connectSrc?: string;
     debug?: boolean;
-    hostLabel?: string;
-    hostIcon?: string;
     popup?: boolean;
     transportReconnect?: boolean;
-    webusb?: boolean;
     transports?: (Transport['name'] | Transport | (new (...args: any[]) => Transport))[];
     pendingTransportEvent?: boolean;
     lazyLoad?: boolean;
     interactionTimeout?: number;
     trustedHost: boolean;
-    coreMode?: 'auto' | 'popup' | 'iframe';
-    _extendWebextensionLifetime?: boolean;
-    _sessionsBackgroundUrl?: string;
-    deeplinkOpen?: (url: string) => void;
-    deeplinkCallbackUrl?: string;
-    deeplinkUrl?: string;
+    _sessionsBackgroundUrl?: null | string;
+    binFilesBaseUrl?: string;
+    enableFirmwareHashCheck?: boolean;
 }
 export interface ConnectSettingsInternal {
     origin?: string;
@@ -42,5 +36,18 @@ export interface ConnectSettingsInternal {
     sharedLogger?: boolean;
     useCoreInPopup?: boolean;
 }
-export type ConnectSettings = ConnectSettingsPublic & ConnectSettingsInternal;
+export interface ConnectSettingsWeb {
+    hostLabel?: string;
+    hostIcon?: string;
+    coreMode?: 'auto' | 'popup' | 'iframe' | 'deeplink';
+}
+export interface ConnectSettingsWebextension {
+    _extendWebextensionLifetime?: boolean;
+}
+export interface ConnectSettingsMobile {
+    deeplinkUrl: string;
+    deeplinkOpen?: (url: string) => void;
+    deeplinkCallbackUrl?: string;
+}
+export type ConnectSettings = ConnectSettingsPublic & ConnectSettingsInternal & ConnectSettingsWeb & ConnectSettingsWebextension & ConnectSettingsMobile;
 //# sourceMappingURL=settings.d.ts.map

package/lib/types/utils.d.ts

@@ -12,4 +12,5 @@ export type MessageFactoryFn<Group, Event> = UnionToIntersection<Event extends {
     type: Event['type'];
     payload: undefined;
 } : never>;
+export declare const typedObjectKeys: <T extends Record<any, any>>(obj: T) => Array<keyof T>;
 //# sourceMappingURL=utils.d.ts.map

package/lib/types/utils.js

@@ -1,3 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedObjectKeys = void 0;
+const typedObjectKeys = (obj) => Object.keys(obj);
+exports.typedObjectKeys = typedObjectKeys;
 //# sourceMappingURL=utils.js.map

package/lib/utils/addressUtils.js

@@ -9,7 +9,7 @@ const isValidBase58Address = (address, network) => {
             return false;
         }
     }
-    catch (e) {
+    catch {
         return false;
     }
     return true;
@@ -21,7 +21,7 @@ const isValidBech32Address = (address, network) => {
             return false;
         }
     }
-    catch (e) {
+    catch {
         return false;
     }
     return true;

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,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAssetByUrl = void 0;
+exports.tryLocalAssetRequire = void 0;
+const utils_1 = require("@trezor/utils");
 const types_1 = require("../types");
-const isDeviceModel = (model) => {
-    return Object.values(types_1.DeviceModelInternal).includes(model);
-};
+const isDeviceModel = (model) => (0, utils_1.isArrayMember)(model, Object.values(types_1.DeviceModelInternal));
 const firmwareAssets = {
     [types_1.DeviceModelInternal.T1B1]: require('@trezor/connect-common/files/firmware/t1b1/releases.json'),
     [types_1.DeviceModelInternal.T2T1]: require('@trezor/connect-common/files/firmware/t2t1/releases.json'),
     [types_1.DeviceModelInternal.T2B1]: require('@trezor/connect-common/files/firmware/t2b1/releases.json'),
     [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'),
+    [types_1.DeviceModelInternal.T3W1]: require('@trezor/connect-common/files/firmware/t3w1/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/deviceFeaturesUtils.js

@@ -88,7 +88,7 @@ const getUnavailableCapabilities = (features, coins) => {
         if (info.shortcut === 'SOL' || info.shortcut === 'DSOL') {
             return !capabilities.includes('Capability_Solana');
         }
-        return !capabilities.includes(`Capability_${info.name}`);
+        return !(0, utils_1.isArrayMember)(`Capability_${info.name}`, capabilities);
     });
     unavailable.forEach(info => {
         list[info.shortcut.toLowerCase()] = 'no-capability';

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/lib/utils/uiPromiseManager.d.ts

@@ -1,10 +1,11 @@
 import { UiPromiseCreator, UiPromiseResponse } from '../events';
+import { DeviceUniquePath } from '../types/device';
 export declare const createUiPromiseManager: (interactionTimeout: () => void) => {
     exists: (type: UiPromiseResponse["type"]) => boolean;
     create: UiPromiseCreator;
     resolve: (event: UiPromiseResponse) => boolean;
     rejectAll: (error: Error) => void;
-    disconnected: (devicePath: string) => boolean;
+    disconnected: (devicePath: DeviceUniquePath) => boolean;
     get: <T extends UiPromiseResponse["type"]>(type: T) => Promise<Extract<import("../events").UiResponsePopupHandshake, {
         type: T;
     }> | Extract<import("../events").UiResponsePermission, {

package/lib/utils/uiPromiseManager.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUiPromiseManager = void 0;
-const events_1 = require("../events");
 const utils_1 = require("@trezor/utils");
+const events_1 = require("../events");
 const createUiPromiseManager = (interactionTimeout) => {
     let _uiPromises = [];
     const exists = (type) => _uiPromises.some(p => p.id === type);
@@ -28,10 +28,10 @@ const createUiPromiseManager = (interactionTimeout) => {
         _uiPromises = [];
     };
     const disconnected = (devicePath) => {
-        const [toResolve, toKeep] = (0, utils_1.arrayPartition)(_uiPromises, (p) => { var _a; return ((_a = p.device) === null || _a === void 0 ? void 0 : _a.getDevicePath()) === devicePath && p.id === events_1.DEVICE.DISCONNECT; });
+        const [toResolve, toKeep] = (0, utils_1.arrayPartition)(_uiPromises, (p) => { var _a; return ((_a = p.device) === null || _a === void 0 ? void 0 : _a.getUniquePath()) === devicePath && p.id === events_1.DEVICE.DISCONNECT; });
         toResolve.forEach(p => p.resolve({ type: events_1.DEVICE.DISCONNECT }));
         _uiPromises = toKeep;
-        return !!toResolve.length || toKeep.some(p => { var _a; return ((_a = p.device) === null || _a === void 0 ? void 0 : _a.getDevicePath()) === devicePath; });
+        return !!toResolve.length || toKeep.some(p => { var _a; return ((_a = p.device) === null || _a === void 0 ? void 0 : _a.getUniquePath()) === devicePath; });
     };
     const get = (type) => {
         var _a;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.4.2",
+  "version": "9.4.3-beta.2",
   "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.",
@@ -70,19 +70,19 @@
   },
   "dependencies": {
     "@babel/preset-typescript": "^7.24.7",
-    "@ethereumjs/common": "^4.3.0",
-    "@ethereumjs/tx": "^5.3.0",
+    "@ethereumjs/common": "^4.4.0",
+    "@ethereumjs/tx": "^5.4.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.2",
+    "@trezor/blockchain-link-types": "1.2.2-beta.2",
     "@trezor/connect-analytics": "1.2.1",
-    "@trezor/connect-common": "0.2.2",
-    "@trezor/protobuf": "1.2.2",
+    "@trezor/connect-common": "0.2.3-beta.2",
+    "@trezor/protobuf": "1.2.3-beta.2",
     "@trezor/protocol": "1.2.1",
-    "@trezor/schema-utils": "1.2.1",
-    "@trezor/transport": "1.3.2",
-    "@trezor/utils": "9.2.1",
-    "@trezor/utxo-lib": "2.2.1",
+    "@trezor/schema-utils": "1.2.2-beta.1",
+    "@trezor/transport": "1.3.3-beta.2",
+    "@trezor/utils": "9.2.2-beta.2",
+    "@trezor/utxo-lib": "2.2.2-beta.1",
     "blakejs": "^1.2.1",
     "bs58": "^6.0.0",
     "bs58check": "^4.0.0",
@@ -103,7 +103,7 @@
     "node-libs-browser": "^2.2.1",
     "ts-node": "^10.9.1",
     "tsx": "^4.16.3",
-    "webpack": "^5.94.0",
+    "webpack": "^5.96.1",
     "ws": "^8.18.0"
   },
   "peerDependencies": {

package/lib/api/checkFirmwareAuthenticity.d.ts

@@ -1,11 +0,0 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { CheckFirmwareAuthenticityParams } from '../types/api/checkFirmwareAuthenticity';
-export default class CheckFirmwareAuthenticity extends AbstractMethod<'checkFirmwareAuthenticity', CheckFirmwareAuthenticityParams> {
-    init(): void;
-    run(): Promise<{
-        expectedFirmwareHash: string;
-        actualFirmwareHash: string;
-        valid: boolean;
-    }>;
-}
-//# sourceMappingURL=checkFirmwareAuthenticity.d.ts.map