@trezor/connect 9.0.10 → 9.0.11

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 9.0.11
+
+-   fix(connect-web): fix imports from connect
+
 # 9.0.10
 
 -   fix(connect-popup): fix connect-popup in firefox

package/README.md

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

package/lib/data/version.d.ts

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

package/lib/data/version.js

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

package/lib/device/Device.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
+import { TypedEmitter } from '@trezor/utils/lib/typedEventEmitter';
 import { DeviceCommands } from './DeviceCommands';
 import { PROTO, NETWORK } from '../constants';
 import { DEVICE, DeviceButtonRequestPayload } from '../events';
@@ -16,19 +15,14 @@ export type RunOptions = {
     useCardanoDerivation?: boolean;
 };
 export interface DeviceEvents {
-    [DEVICE.PIN]: [Device, PROTO.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
-    [DEVICE.WORD]: [Device, PROTO.WordRequestType, (err: any, word: string) => void];
-    [DEVICE.PASSPHRASE]: [Device, (response: any) => void];
-    [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
-    [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
-    [DEVICE.ACQUIRED]: [];
+    [DEVICE.PIN]: (device: Device, b: PROTO.PinMatrixRequestType | undefined, callback: (err: any, pin: string) => void) => void;
+    [DEVICE.WORD]: (device: Device, b: PROTO.WordRequestType, callback: (err: any, word: string) => void) => void;
+    [DEVICE.PASSPHRASE]: (device: Device, callback: (response: any) => void) => void;
+    [DEVICE.PASSPHRASE_ON_DEVICE]: () => void;
+    [DEVICE.BUTTON]: (device: Device, payload: DeviceButtonRequestPayload) => void;
+    [DEVICE.ACQUIRED]: () => void;
 }
-export interface Device {
-    on<K extends keyof DeviceEvents>(type: K, listener: (...event: DeviceEvents[K]) => void): this;
-    off<K extends keyof DeviceEvents>(type: K, listener: (...event: DeviceEvents[K]) => void): this;
-    emit<K extends keyof DeviceEvents>(type: K, ...args: DeviceEvents[K]): boolean;
-}
-export declare class Device extends EventEmitter {
+export declare class Device extends TypedEmitter<DeviceEvents> {
     transport: Transport;
     originalDescriptor: DeviceDescriptor;
     unreadableError?: string;

package/lib/device/Device.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
-const tslib_1 = require("tslib");
-const events_1 = tslib_1.__importDefault(require("events"));
+const typedEventEmitter_1 = require("@trezor/utils/lib/typedEventEmitter");
 const DeviceCommands_1 = require("./DeviceCommands");
 const constants_1 = require("../constants");
-const events_2 = require("../events");
+const events_1 = require("../events");
 const coinInfo_1 = require("../data/coinInfo");
 const firmwareInfo_1 = require("../data/firmwareInfo");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
@@ -18,7 +17,7 @@ const parseRunOptions = (options) => {
         options = {};
     return options;
 };
-class Device extends events_1.default {
+class Device extends typedEventEmitter_1.TypedEmitter {
     constructor(transport, descriptor) {
         super();
         this.featuresNeedsReload = false;
@@ -53,8 +52,8 @@ class Device extends events_1.default {
         return device;
     }
     async acquire() {
-        this.deferredActions[events_2.DEVICE.ACQUIRE] = (0, deferred_1.create)();
-        this.deferredActions[events_2.DEVICE.ACQUIRED] = (0, deferred_1.create)();
+        this.deferredActions[events_1.DEVICE.ACQUIRE] = (0, deferred_1.create)();
+        this.deferredActions[events_1.DEVICE.ACQUIRED] = (0, deferred_1.create)();
         try {
             const sessionID = await this.transport.acquire({
                 path: this.originalDescriptor.path,
@@ -62,17 +61,17 @@ class Device extends events_1.default {
             }, false);
             _log.debug('Expected session id:', sessionID);
             this.activitySessionID = sessionID;
-            this.deferredActions[events_2.DEVICE.ACQUIRED].resolve();
-            delete this.deferredActions[events_2.DEVICE.ACQUIRED];
+            this.deferredActions[events_1.DEVICE.ACQUIRED].resolve();
+            delete this.deferredActions[events_1.DEVICE.ACQUIRED];
             if (this.commands) {
                 this.commands.dispose();
             }
             this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, sessionID);
-            this.deferredActions[events_2.DEVICE.RELEASE] = (0, deferred_1.create)();
+            this.deferredActions[events_1.DEVICE.RELEASE] = (0, deferred_1.create)();
         }
         catch (error) {
-            this.deferredActions[events_2.DEVICE.ACQUIRED].resolve();
-            delete this.deferredActions[events_2.DEVICE.ACQUIRED];
+            this.deferredActions[events_1.DEVICE.ACQUIRED].resolve();
+            delete this.deferredActions[events_1.DEVICE.ACQUIRED];
             if (this.runPromise) {
                 this.runPromise.reject(error);
             }
@@ -97,8 +96,8 @@ class Device extends events_1.default {
             }
             try {
                 await this.transport.release(this.activitySessionID, false, false);
-                if (this.deferredActions[events_2.DEVICE.RELEASE])
-                    await this.deferredActions[events_2.DEVICE.RELEASE].promise;
+                if (this.deferredActions[events_1.DEVICE.RELEASE])
+                    await this.deferredActions[events_1.DEVICE.RELEASE].promise;
             }
             catch (err) {
             }
@@ -119,14 +118,14 @@ class Device extends events_1.default {
         return this.runPromise.promise;
     }
     async override(error) {
-        if (this.deferredActions[events_2.DEVICE.ACQUIRE]) {
-            await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
+        if (this.deferredActions[events_1.DEVICE.ACQUIRE]) {
+            await this.deferredActions[events_1.DEVICE.ACQUIRE].promise;
         }
         if (this.runPromise) {
             await this.interruptionFromUser(error);
         }
-        if (!this.keepSession && this.deferredActions[events_2.DEVICE.RELEASE]) {
-            await this.deferredActions[events_2.DEVICE.RELEASE].promise;
+        if (!this.keepSession && this.deferredActions[events_1.DEVICE.RELEASE]) {
+            await this.deferredActions[events_1.DEVICE.RELEASE].promise;
         }
     }
     async interruptionFromUser(error) {
@@ -171,7 +170,7 @@ class Device extends events_1.default {
                     return this._runInner(() => Promise.resolve({}), options);
                 }
                 this.inconsistent = true;
-                await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
+                await this.deferredActions[events_1.DEVICE.ACQUIRE].promise;
                 this.runPromise = null;
                 return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}, code: ${error.code}`));
             }
@@ -179,7 +178,7 @@ class Device extends events_1.default {
         if (options.keepSession) {
             this.keepSession = true;
         }
-        await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
+        await this.deferredActions[events_1.DEVICE.ACQUIRE].promise;
         if (fn) {
             await fn();
         }
@@ -335,21 +334,21 @@ class Device extends events_1.default {
         if (!originalSession && !upcomingSession && !this.activitySessionID) {
             return;
         }
-        if (this.deferredActions[events_2.DEVICE.ACQUIRED]) {
-            await this.deferredActions[events_2.DEVICE.ACQUIRED].promise;
+        if (this.deferredActions[events_1.DEVICE.ACQUIRED]) {
+            await this.deferredActions[events_1.DEVICE.ACQUIRED].promise;
         }
         if (!upcomingSession) {
-            if (this.listeners(events_2.DEVICE.ACQUIRED).length > 0) {
-                this.emit(events_2.DEVICE.ACQUIRED);
+            if (this.listeners(events_1.DEVICE.ACQUIRED).length > 0) {
+                this.emit(events_1.DEVICE.ACQUIRED);
             }
         }
         const methodStillRunning = this.commands && !this.commands.disposed;
         if (!upcomingSession && !methodStillRunning) {
             if (originalSession === this.activitySessionID) {
                 _log.debug('Session released by this app');
-                if (this.deferredActions[events_2.DEVICE.RELEASE]) {
-                    this.deferredActions[events_2.DEVICE.RELEASE].resolve();
-                    delete this.deferredActions[events_2.DEVICE.RELEASE];
+                if (this.deferredActions[events_1.DEVICE.RELEASE]) {
+                    this.deferredActions[events_1.DEVICE.RELEASE].resolve();
+                    delete this.deferredActions[events_1.DEVICE.RELEASE];
                 }
                 this.activitySessionID = null;
             }
@@ -361,8 +360,8 @@ class Device extends events_1.default {
         }
         else if (upcomingSession === this.activitySessionID) {
             _log.debug('Session acquired by this app');
-            if (this.deferredActions[events_2.DEVICE.ACQUIRE]) {
-                this.deferredActions[events_2.DEVICE.ACQUIRE].resolve();
+            if (this.deferredActions[events_1.DEVICE.ACQUIRE]) {
+                this.deferredActions[events_1.DEVICE.ACQUIRE].resolve();
             }
         }
         else {
@@ -373,9 +372,9 @@ class Device extends events_1.default {
     }
     disconnect() {
         _log.debug('Disconnect cleanup');
-        if (this.deferredActions[events_2.DEVICE.RELEASE]) {
-            this.deferredActions[events_2.DEVICE.RELEASE].resolve();
-            delete this.deferredActions[events_2.DEVICE.RELEASE];
+        if (this.deferredActions[events_1.DEVICE.RELEASE]) {
+            this.deferredActions[events_1.DEVICE.RELEASE].resolve();
+            delete this.deferredActions[events_1.DEVICE.RELEASE];
         }
         this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
         this.runPromise = null;
@@ -433,17 +432,17 @@ class Device extends events_1.default {
     }
     hasUnexpectedMode(allow, require) {
         if (this.features) {
-            if (this.isBootloader() && !allow.includes(events_2.UI.BOOTLOADER)) {
-                return events_2.UI.BOOTLOADER;
+            if (this.isBootloader() && !allow.includes(events_1.UI.BOOTLOADER)) {
+                return events_1.UI.BOOTLOADER;
             }
-            if (!this.isInitialized() && !allow.includes(events_2.UI.INITIALIZE)) {
-                return events_2.UI.INITIALIZE;
+            if (!this.isInitialized() && !allow.includes(events_1.UI.INITIALIZE)) {
+                return events_1.UI.INITIALIZE;
             }
-            if (this.isSeedless() && !allow.includes(events_2.UI.SEEDLESS)) {
-                return events_2.UI.SEEDLESS;
+            if (this.isSeedless() && !allow.includes(events_1.UI.SEEDLESS)) {
+                return events_1.UI.SEEDLESS;
             }
-            if (!this.isBootloader() && require.includes(events_2.UI.BOOTLOADER)) {
-                return events_2.UI.NOT_IN_BOOTLOADER;
+            if (!this.isBootloader() && require.includes(events_1.UI.BOOTLOADER)) {
+                return events_1.UI.NOT_IN_BOOTLOADER;
             }
         }
         return null;

package/lib/device/DeviceCommands.js

@@ -293,7 +293,7 @@ class DeviceCommands {
                 res.message.code = 'ButtonRequest_PassphraseType';
             }
             if (res.message.code === 'ButtonRequest_PassphraseEntry') {
-                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE, this.device);
+                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
             }
             else {
                 this.device.emit(events_1.DEVICE.BUTTON, this.device, res.message);
@@ -316,7 +316,7 @@ class DeviceCommands {
                 return this._commonCall('PassphraseAck', { passphrase: state });
             }
             if (legacy && res.message._on_device) {
-                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE, this.device);
+                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
                 return this._commonCall('PassphraseAck', { _state: state });
             }
             return this._promptPassphrase().then(response => {

package/lib/device/DeviceList.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
+import { TypedEmitter } from '@trezor/utils/lib/typedEventEmitter';
 import { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
 import { TRANSPORT, DEVICE, TransportInfo } from '../events';
 import { DescriptorStream } from './DescriptorStream';
@@ -23,12 +22,7 @@ interface DeviceListEvents {
     [DEVICE.RELEASED]: DeviceTyped;
     [DEVICE.ACQUIRED]: DeviceTyped;
 }
-export interface DeviceList {
-    on<K extends keyof DeviceListEvents>(type: K, listener: (event: DeviceListEvents[K]) => void): this;
-    off<K extends keyof DeviceListEvents>(type: K, listener: (event: DeviceListEvents[K]) => void): this;
-    emit<K extends keyof DeviceListEvents>(type: K, args: DeviceListEvents[K]): boolean;
-}
-export declare class DeviceList extends EventEmitter {
+export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
     transport: Transport;
     transportPlugin: LowLevelPlugin | typeof undefined;
     stream: DescriptorStream;

package/lib/device/DeviceList.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDeviceList = exports.DeviceList = void 0;
 const tslib_1 = require("tslib");
-const events_1 = tslib_1.__importDefault(require("events"));
+const typedEventEmitter_1 = require("@trezor/utils/lib/typedEventEmitter");
 const transport_1 = tslib_1.__importDefault(require("@trezor/transport"));
 const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
 const constants_1 = require("../constants");
-const events_2 = require("../events");
+const events_1 = require("../events");
 const DescriptorStream_1 = require("./DescriptorStream");
 const Device_1 = require("./Device");
 const DataManager_1 = require("../data/DataManager");
@@ -17,7 +17,7 @@ const workers_1 = require("../workers/workers");
 const { BridgeV2, Fallback } = transport_1.default;
 const _log = (0, debug_1.initLog)('DeviceList');
 let autoResolveTransportEventTimeout;
-class DeviceList extends events_1.default {
+class DeviceList extends typedEventEmitter_1.TypedEmitter {
     constructor() {
         var _a;
         super();
@@ -64,49 +64,49 @@ class DeviceList extends events_1.default {
                 this.transportPlugin = transport.activeTransport.plugin;
             }
             await this._initStream();
-            this.on(events_2.DEVICE.CONNECT, this.resolveTransportEvent.bind(this));
-            this.on(events_2.DEVICE.CONNECT_UNACQUIRED, this.resolveTransportEvent.bind(this));
+            this.on(events_1.DEVICE.CONNECT, this.resolveTransportEvent.bind(this));
+            this.on(events_1.DEVICE.CONNECT_UNACQUIRED, this.resolveTransportEvent.bind(this));
         }
         catch (error) {
-            this.emit(events_2.TRANSPORT.ERROR, error);
+            this.emit(events_1.TRANSPORT.ERROR, error);
         }
     }
     resolveTransportEvent() {
         this.transportStartPending--;
         if (this.transportStartPending === 0) {
-            this.stream.emit(events_2.TRANSPORT.START);
+            this.stream.emit(events_1.TRANSPORT.START);
         }
     }
     async waitForTransportFirstEvent() {
         await new Promise(resolve => {
             const handler = () => {
-                this.removeListener(events_2.TRANSPORT.START, handler);
-                this.removeListener(events_2.TRANSPORT.ERROR, handler);
+                this.removeListener(events_1.TRANSPORT.START, handler);
+                this.removeListener(events_1.TRANSPORT.ERROR, handler);
                 resolve();
             };
-            this.on(events_2.TRANSPORT.START, handler);
-            this.on(events_2.TRANSPORT.ERROR, handler);
+            this.on(events_1.TRANSPORT.START, handler);
+            this.on(events_1.TRANSPORT.ERROR, handler);
         });
     }
     _initStream() {
         const stream = new DescriptorStream_1.DescriptorStream(this.transport);
-        stream.on(events_2.TRANSPORT.START_PENDING, (pending) => {
+        stream.on(events_1.TRANSPORT.START_PENDING, (pending) => {
             this.transportStartPending = pending;
             autoResolveTransportEventTimeout = setTimeout(() => {
                 this.resolveTransportEvent();
             }, 5000);
         });
-        stream.on(events_2.TRANSPORT.START, () => {
-            this.emit(events_2.TRANSPORT.START, this.getTransportInfo());
+        stream.on(events_1.TRANSPORT.START, () => {
+            this.emit(events_1.TRANSPORT.START, this.getTransportInfo());
             if (autoResolveTransportEventTimeout) {
                 clearTimeout(autoResolveTransportEventTimeout);
             }
         });
-        stream.on(events_2.TRANSPORT.UPDATE, (diff) => {
+        stream.on(events_1.TRANSPORT.UPDATE, (diff) => {
             new DiffHandler(this, diff).handle();
         });
-        stream.on(events_2.TRANSPORT.ERROR, error => {
-            this.emit(events_2.TRANSPORT.ERROR, error);
+        stream.on(events_1.TRANSPORT.ERROR, error => {
+            this.emit(events_1.TRANSPORT.ERROR, error);
             stream.stop();
         });
         stream.listen();
@@ -123,16 +123,16 @@ class DeviceList extends events_1.default {
                         debug: false,
                     }, 'HID_DEVICE');
                     this.devices[UNREADABLE_PATH] = device;
-                    this.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+                    this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
                 }
                 else {
                     const device = this.devices[UNREADABLE_PATH];
                     delete this.devices[UNREADABLE_PATH];
-                    this.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
+                    this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
                 }
             });
         }
-        this.emit(events_2.TRANSPORT.STREAM, stream);
+        this.emit(events_1.TRANSPORT.STREAM, stream);
     }
     async _createAndSaveDevice(descriptor) {
         _log.debug('Creating Device', descriptor);
@@ -141,8 +141,8 @@ class DeviceList extends events_1.default {
     _createUnacquiredDevice(descriptor) {
         _log.debug('Creating Unacquired Device', descriptor);
         const device = Device_1.Device.createUnacquired(this.transport, descriptor);
-        device.once(events_2.DEVICE.ACQUIRED, () => {
-            this.emit(events_2.DEVICE.CONNECT, device.toMessageObject());
+        device.once(events_1.DEVICE.ACQUIRED, () => {
+            this.emit(events_1.DEVICE.CONNECT, device.toMessageObject());
         });
         return device;
     }
@@ -196,7 +196,7 @@ class DeviceList extends events_1.default {
     }
     disconnectDevices() {
         this.allDevices().forEach(device => {
-            this.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
+            this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
         });
     }
     enumerate() {
@@ -262,7 +262,7 @@ class CreateDeviceHandler {
             else if (((_a = error.message) === null || _a === void 0 ? void 0 : _a.indexOf(constants_1.ERRORS.LIBUSB_ERROR_MESSAGE)) >= 0) {
                 const device = this.list._createUnreadableDevice(this.list.creatingDevicesDescriptors[this.path], error.message);
                 this.list.devices[this.path] = device;
-                this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+                this.list.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
             }
             else if (error.code === 'Device_InitializeFailed') {
                 this._handleUsedElsewhere();
@@ -281,12 +281,12 @@ class CreateDeviceHandler {
         const device = Device_1.Device.fromDescriptor(this.list.transport, this.descriptor);
         this.list.devices[this.path] = device;
         await device.run();
-        this.list.emit(events_2.DEVICE.CONNECT, device.toMessageObject());
+        this.list.emit(events_1.DEVICE.CONNECT, device.toMessageObject());
     }
     _handleUsedElsewhere() {
         const device = this.list._createUnacquiredDevice(this.list.creatingDevicesDescriptors[this.path]);
         this.list.devices[this.path] = device;
-        this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+        this.list.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
     }
 }
 class DiffHandler {
@@ -316,15 +316,15 @@ class DiffHandler {
         const events = [
             {
                 d: this.diff.changedSessions,
-                e: events_2.DEVICE.CHANGED,
+                e: events_1.DEVICE.CHANGED,
             },
             {
                 d: this.diff.acquired,
-                e: events_2.DEVICE.ACQUIRED,
+                e: events_1.DEVICE.ACQUIRED,
             },
             {
                 d: this.diff.released,
-                e: events_2.DEVICE.RELEASED,
+                e: events_1.DEVICE.RELEASED,
             },
         ];
         events.forEach(({ d, e }) => {
@@ -353,7 +353,7 @@ class DiffHandler {
             else {
                 const device = await this.list._createUnacquiredDevice(descriptor);
                 this.list.devices[path] = device;
-                this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+                this.list.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
             }
         });
     }
@@ -385,7 +385,7 @@ class DiffHandler {
             if (device != null) {
                 device.disconnect();
                 delete this.list.devices[path];
-                this.list.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
+                this.list.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.0.10",
+  "version": "9.0.11",
   "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.",
@@ -49,37 +49,37 @@
     "prepublish": "yarn tsx ../../scripts/prepublish.js"
   },
   "dependencies": {
-    "@trezor/blockchain-link": "2.1.12",
-    "@trezor/connect-analytics": "1.0.1",
-    "@trezor/connect-common": "0.0.15",
-    "@trezor/transport": "1.1.11",
-    "@trezor/utils": "9.0.8",
-    "@trezor/utxo-lib": "1.0.6",
+    "@trezor/blockchain-link": "2.1.13",
+    "@trezor/connect-analytics": "1.0.2",
+    "@trezor/connect-common": "0.0.16",
+    "@trezor/transport": "1.1.12",
+    "@trezor/utils": "9.0.9",
+    "@trezor/utxo-lib": "1.0.7",
     "bignumber.js": "^9.1.1",
     "blakejs": "^1.2.1",
-    "cross-fetch": "^3.1.5",
+    "cross-fetch": "^3.1.6",
     "events": "^3.3.0",
     "randombytes": "2.1.0",
-    "tslib": "2.5.0"
+    "tslib": "2.5.2"
   },
   "devDependencies": {
-    "@trezor/trezor-user-env-link": "1.0.1",
+    "@trezor/trezor-user-env-link": "1.0.2",
     "@types/karma": "^6.3.3",
     "@types/parse-uri": "^1.0.0",
     "@types/randombytes": "^2.0.0",
     "jest": "^29.5.0",
     "jest-environment-jsdom": "^29.5.0",
-    "karma": "^6.4.1",
+    "karma": "^6.4.2",
     "karma-babel-preprocessor": "^8.0.2",
-    "karma-chrome-launcher": "^3.1.1",
+    "karma-chrome-launcher": "^3.2.0",
     "karma-jasmine": "^5.1.0",
     "karma-jasmine-async": "^0.0.1",
     "karma-sourcemap-loader": "^0.4.0",
     "karma-webpack": "^5.0.0",
-    "rimraf": "^4.4.1",
+    "rimraf": "^5.0.1",
     "ts-loader": "^9.4.2",
     "ts-node": "^10.9.1",
-    "tsx": "^3.12.6",
+    "tsx": "^3.12.7",
     "typescript": "4.9.5"
   }
 }