@trezor/connect 9.2.3 → 9.2.4-beta.2

package/lib/device/DeviceCommands.js

@@ -67,13 +67,10 @@ class DeviceCommands {
         });
         return response.message;
     }
-    async getHDNode(params, options = {}) {
+    async getHDNode(params, options) {
         const path = params.address_n;
         const { coinInfo, unlockPath } = options;
         const validation = typeof options.validation === 'boolean' ? options.validation : true;
-        if (!this.device.atLeast(['1.7.2', '2.0.10']) || !coinInfo) {
-            return this.getBitcoinHDNode(path, coinInfo);
-        }
         let network = null;
         if (!params.script_type) {
             params.script_type = (0, pathUtils_1.getScriptType)(path);
@@ -125,42 +122,6 @@ class DeviceCommands {
         }
         return response;
     }
-    async getBitcoinHDNode(path, coinInfo, validation = true) {
-        let publicKey;
-        if (!validation) {
-            publicKey = await this.getPublicKey({ address_n: path });
-        }
-        else {
-            const suffix = 0;
-            const childPath = path.concat([suffix]);
-            const resKey = await this.getPublicKey({ address_n: path });
-            const childKey = await this.getPublicKey({ address_n: childPath });
-            publicKey = hdnodeUtils.xpubDerive(resKey, childKey, suffix);
-        }
-        const response = {
-            path,
-            serializedPath: (0, pathUtils_1.getSerializedPath)(path),
-            childNum: publicKey.node.child_num,
-            xpub: coinInfo
-                ? hdnodeUtils.convertBitcoinXpub(publicKey.xpub, coinInfo.network)
-                : publicKey.xpub,
-            chainCode: publicKey.node.chain_code,
-            publicKey: publicKey.node.public_key,
-            fingerprint: publicKey.node.fingerprint,
-            depth: publicKey.node.depth,
-        };
-        if (coinInfo) {
-            const bech32Network = (0, coinInfo_1.getBech32Network)(coinInfo);
-            const segwitNetwork = (0, coinInfo_1.getSegwitNetwork)(coinInfo);
-            if (bech32Network && (0, pathUtils_1.isBech32Path)(path)) {
-                response.xpubSegwit = hdnodeUtils.convertBitcoinXpub(publicKey.xpub, bech32Network);
-            }
-            else if (segwitNetwork && (0, pathUtils_1.isSegwitPath)(path)) {
-                response.xpubSegwit = hdnodeUtils.convertBitcoinXpub(publicKey.xpub, segwitNetwork);
-            }
-        }
-        return response;
-    }
     async getAddress({ address_n, show_display, multisig, script_type, chunkify }, coinInfo) {
         if (!script_type) {
             script_type = (0, pathUtils_1.getScriptType)(address_n);
@@ -203,9 +164,6 @@ class DeviceCommands {
         };
     }
     async ethereumGetPublicKey({ address_n, show_display, }) {
-        if (!this.device.atLeast(['1.8.1', '2.1.0'])) {
-            return this.getHDNode({ address_n });
-        }
         const suffix = 0;
         const childPath = address_n.concat([suffix]);
         const resKey = await this.typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
@@ -239,11 +197,8 @@ class DeviceCommands {
             return false;
         }
     }
-    getDeviceState(networkType) {
-        if (!this.device.atLeast('2.4.3')) {
-            return this._getAddressForNetworkType(networkType);
-        }
-        return this._getAddressForNetworkType();
+    getDeviceState() {
+        return this._getAddress();
     }
     async call(type, msg = {}) {
         logger.debug('Sending', type, filterForLog(type, msg));
@@ -366,30 +321,13 @@ class DeviceCommands {
         }
         return Promise.resolve(res);
     }
-    async _getAddressForNetworkType(networkType) {
-        switch (networkType) {
-            case constants_1.NETWORK.TYPES.cardano: {
-                const { message } = await this.typedCall('CardanoGetAddress', 'CardanoAddress', {
-                    address_parameters: {
-                        address_type: 8,
-                        address_n: [(0, pathUtils_1.toHardened)(44), (0, pathUtils_1.toHardened)(1815), (0, pathUtils_1.toHardened)(0), 0, 0],
-                        address_n_staking: [],
-                    },
-                    protocol_magic: 42,
-                    network_id: 0,
-                    derivation_type: 2,
-                });
-                return message.address;
-            }
-            default: {
-                const { message } = await this.typedCall('GetAddress', 'Address', {
-                    address_n: [(0, pathUtils_1.toHardened)(44), (0, pathUtils_1.toHardened)(1), (0, pathUtils_1.toHardened)(0), 0, 0],
-                    coin_name: 'Testnet',
-                    script_type: 'SPENDADDRESS',
-                });
-                return message.address;
-            }
-        }
+    async _getAddress() {
+        const { message } = await this.typedCall('GetAddress', 'Address', {
+            address_n: [(0, pathUtils_1.toHardened)(44), (0, pathUtils_1.toHardened)(1), (0, pathUtils_1.toHardened)(0), 0, 0],
+            coin_name: 'Testnet',
+            script_type: 'SPENDADDRESS',
+        });
+        return message.address;
     }
     _promptPin(type) {
         return new Promise((resolve, reject) => {

package/lib/device/DeviceList.d.ts

@@ -2,7 +2,7 @@ import { TypedEmitter } from '@trezor/utils';
 import { Transport, TRANSPORT, Descriptor } from '@trezor/transport';
 import { DEVICE, TransportInfo } from '../events';
 import { Device } from './Device';
-import type { Device as DeviceTyped } from '../types';
+import type { ConnectSettings, Device as DeviceTyped } from '../types';
 interface DeviceListEvents {
     [TRANSPORT.START]: TransportInfo;
     [TRANSPORT.ERROR]: string;
@@ -19,7 +19,6 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
     devices: {
         [path: string]: Device;
     };
-    messages: JSON | Record<string, any>;
     creatingDevicesDescriptors: {
         [k: string]: Descriptor;
     };
@@ -28,7 +27,11 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
         [deviceID: string]: number;
     };
     transportFirstEventPromise: Promise<void> | undefined;
-    constructor();
+    private settings;
+    constructor({ settings, messages, }: {
+        settings: ConnectSettings;
+        messages: Record<string, any>;
+    });
     init(): Promise<void>;
     private resolveTransportEvent;
     waitForTransportFirstEvent(): Promise<void>;
@@ -42,7 +45,7 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
     length(): number;
     transportType(): "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport";
     getTransportInfo(): TransportInfo;
-    dispose(): Promise<void>;
+    dispose(): void;
     disconnectDevices(): void;
     enumerate(): Promise<void>;
     addAuthPenalty(device: Device): void;

package/lib/device/DeviceList.js

@@ -6,62 +6,62 @@ const transport_1 = require("@trezor/transport");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const Device_1 = require("./Device");
-const DataManager_1 = require("../data/DataManager");
 const transportInfo_1 = require("../data/transportInfo");
 const debug_1 = require("../utils/debug");
 const promiseUtils_1 = require("../utils/promiseUtils");
 const _log = (0, debug_1.initLog)('DeviceList');
 let autoResolveTransportEventTimeout;
 class DeviceList extends utils_1.TypedEmitter {
-    constructor() {
+    constructor({ settings, messages, }) {
         super();
         this.transports = [];
         this.devices = {};
         this.creatingDevicesDescriptors = {};
         this.transportStartPending = 0;
         this.penalizedDevices = {};
-        let { transports } = DataManager_1.DataManager.getSettings();
-        const { debug } = DataManager_1.DataManager.getSettings();
-        this.messages = DataManager_1.DataManager.getProtobufMessages();
-        if (!(transports === null || transports === void 0 ? void 0 : transports.length)) {
-            transports = ['BridgeTransport'];
+        this.settings = settings;
+        const transports = [...(settings.transports || [])];
+        if (!transports.length) {
+            transports.push('BridgeTransport');
         }
-        const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
+        const transportLogger = (0, debug_1.initLog)('@trezor/transport', this.settings.debug);
+        const abortController = new AbortController();
+        const transportCommonArgs = {
+            messages,
+            logger: transportLogger,
+            signal: abortController.signal,
+        };
         transports.forEach(transportType => {
             if (typeof transportType === 'string') {
                 switch (transportType) {
                     case 'WebUsbTransport':
-                        this.transports.push(new transport_1.WebUsbTransport({
-                            messages: this.messages,
-                            logger: transportLogger,
-                        }));
+                        this.transports.push(new transport_1.WebUsbTransport(transportCommonArgs));
                         break;
                     case 'NodeUsbTransport':
-                        this.transports.push(new transport_1.NodeUsbTransport({
-                            messages: this.messages,
-                            logger: transportLogger,
-                        }));
+                        this.transports.push(new transport_1.NodeUsbTransport(transportCommonArgs));
                         break;
                     case 'BridgeTransport':
                         this.transports.push(new transport_1.BridgeTransport({
                             latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
-                            messages: this.messages,
-                            logger: transportLogger,
+                            ...transportCommonArgs,
                         }));
                         break;
                     case 'UdpTransport':
-                        this.transports.push(new transport_1.UdpTransport({
-                            logger: transportLogger,
-                            messages: this.messages,
-                        }));
+                        this.transports.push(new transport_1.UdpTransport(transportCommonArgs));
                         break;
                     default:
                         throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
                 }
             }
+            else if (typeof transportType === 'function' && 'prototype' in transportType) {
+                const transportInstance = new transportType(transportCommonArgs);
+                if ((0, transport_1.isTransportInstance)(transportInstance)) {
+                    this.transports.push(transportInstance);
+                }
+            }
             else if ((0, transport_1.isTransportInstance)(transportType)) {
                 if (!transportType.getMessage()) {
-                    transportType.updateMessages(this.messages);
+                    transportType.updateMessages(messages);
                 }
                 this.transports.push(transportType);
             }
@@ -90,14 +90,24 @@ class DeviceList extends utils_1.TypedEmitter {
                 return;
             }
             this.transport.on(transport_1.TRANSPORT.UPDATE, diff => {
+                diff.disconnected.forEach(descriptor => {
+                    const path = descriptor.path.toString();
+                    const device = this.devices[path];
+                    if (device) {
+                        device.disconnect();
+                        delete this.devices[path];
+                        this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
+                    }
+                });
                 diff.connected.forEach(async (descriptor) => {
                     const path = descriptor.path.toString();
-                    const priority = DataManager_1.DataManager.getSettings('priority');
+                    this.creatingDevicesDescriptors[path] = descriptor;
+                    const { priority } = this.settings;
                     const penalty = this.getAuthPenalty();
                     if (priority || penalty) {
                         await (0, promiseUtils_1.resolveAfter)(501 + penalty + 100 * priority, null).promise;
                     }
-                    if (descriptor.session == null) {
+                    if (this.creatingDevicesDescriptors[path].session == null) {
                         await this._createAndSaveDevice(descriptor);
                     }
                     else {
@@ -158,20 +168,13 @@ class DeviceList extends utils_1.TypedEmitter {
                         }
                     });
                 });
-                diff.disconnected.forEach(descriptor => {
-                    const path = descriptor.path.toString();
-                    const device = this.devices[path];
-                    if (device) {
-                        device.disconnect();
-                        delete this.devices[path];
-                        this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
-                    }
-                });
                 diff.descriptors.forEach(d => {
+                    this.creatingDevicesDescriptors[d.path] = d;
                     if (this.devices[d.path]) {
                         this.devices[d.path].originalDescriptor = {
                             session: d.session,
                             path: d.path,
+                            product: d.product,
                         };
                     }
                 });
@@ -185,7 +188,7 @@ class DeviceList extends utils_1.TypedEmitter {
                 return;
             }
             const descriptors = enumerateResult.payload;
-            if (descriptors.length > 0 && DataManager_1.DataManager.getSettings('pendingTransportEvent')) {
+            if (descriptors.length > 0 && this.settings.pendingTransportEvent) {
                 this.transportStartPending = descriptors.length;
                 this.on(events_1.DEVICE.CONNECT, this.resolveTransportEvent.bind(this));
                 this.on(events_1.DEVICE.CONNECT_UNACQUIRED, this.resolveTransportEvent.bind(this));
@@ -265,13 +268,14 @@ class DeviceList extends utils_1.TypedEmitter {
             outdated: this.transport.isOutdated,
         };
     }
-    async dispose() {
+    dispose() {
         this.removeAllListeners();
         if (autoResolveTransportEventTimeout) {
             clearTimeout(autoResolveTransportEventTimeout);
         }
-        await Promise.all(this.allDevices().map(device => device.dispose()));
-        this.transport.stop();
+        Promise.all(this.allDevices().map(device => device.dispose())).then(() => {
+            this.transport.stop();
+        });
     }
     disconnectDevices() {
         this.allDevices().forEach(device => {
@@ -288,6 +292,7 @@ class DeviceList extends utils_1.TypedEmitter {
                 this.devices[d.path].originalDescriptor = {
                     session: d.session,
                     path: d.path,
+                    product: d.product,
                 };
                 this.devices[d.path].activitySessionID = d.session;
             }
@@ -315,7 +320,6 @@ class DeviceList extends utils_1.TypedEmitter {
     async handle(descriptor) {
         var _a;
         const path = descriptor.path.toString();
-        this.creatingDevicesDescriptors[path] = descriptor;
         try {
             await this._takeAndCreateDevice(descriptor);
         }
@@ -324,7 +328,9 @@ class DeviceList extends utils_1.TypedEmitter {
             if (error.code === 'Device_NotFound' ||
                 error.message === transport_1.TRANSPORT_ERROR.DEVICE_NOT_FOUND ||
                 error.message === transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION ||
-                error.message === transport_1.TRANSPORT_ERROR.UNEXPECTED_ERROR) {
+                error.message === transport_1.TRANSPORT_ERROR.UNEXPECTED_ERROR ||
+                error.message === transport_1.TRANSPORT_ERROR.DESCRIPTOR_NOT_FOUND ||
+                error.message === transport_1.TRANSPORT_ERROR.HTTP_ERROR) {
                 delete this.devices[path];
             }
             else if (error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {

package/lib/events/blockchain.d.ts

@@ -1,4 +1,4 @@
-import type { ServerInfo, BlockEvent, FiatRatesLegacy, NotificationEvent } from '@trezor/blockchain-link';
+import type { ServerInfo, BlockEvent, FiatRatesBySymbol, NotificationEvent } from '@trezor/blockchain-link';
 import type { CoinInfo } from '../types/coinInfo';
 import type { MessageFactoryFn } from '../types/utils';
 export declare const BLOCKCHAIN_EVENT = "BLOCKCHAIN_EVENT";
@@ -37,7 +37,7 @@ export interface BlockchainNotification {
 }
 export interface BlockchainFiatRatesUpdate {
     coin: CoinInfo;
-    rates: FiatRatesLegacy;
+    rates: FiatRatesBySymbol;
 }
 export type BlockchainEvent = {
     type: typeof BLOCKCHAIN.CONNECT;

package/lib/events/index.d.ts

@@ -33,6 +33,7 @@ export declare const UI: {
     readonly FIRMWARE_NOT_COMPATIBLE: "ui-device_firmware_not_compatible";
     readonly FIRMWARE_NOT_INSTALLED: "ui-device_firmware_not_installed";
     readonly FIRMWARE_PROGRESS: "ui-firmware-progress";
+    readonly FIRMWARE_RECONNECT: "ui-firmware_reconnect";
     readonly DEVICE_NEEDS_BACKUP: "ui-device_needs_backup";
     readonly REQUEST_UI_WINDOW: "ui-request_window";
     readonly CLOSE_UI_WINDOW: "ui-close_window";

package/lib/events/ui-request.d.ts

@@ -18,6 +18,7 @@ export declare const UI_REQUEST: {
     readonly FIRMWARE_NOT_COMPATIBLE: "ui-device_firmware_not_compatible";
     readonly FIRMWARE_NOT_INSTALLED: "ui-device_firmware_not_installed";
     readonly FIRMWARE_PROGRESS: "ui-firmware-progress";
+    readonly FIRMWARE_RECONNECT: "ui-firmware_reconnect";
     readonly DEVICE_NEEDS_BACKUP: "ui-device_needs_backup";
     readonly REQUEST_UI_WINDOW: "ui-request_window";
     readonly CLOSE_UI_WINDOW: "ui-close_window";
@@ -196,10 +197,21 @@ export interface FirmwareProgress {
     type: typeof UI_REQUEST.FIRMWARE_PROGRESS;
     payload: {
         device: Device;
+        operation: 'downloading' | 'flashing' | 'validating';
         progress: number;
     };
 }
-export type UiEvent = UiRequestWithoutPayload | UiRequestDeviceAction | UiRequestButton | UiRequestPermission | UiRequestConfirmation | UiRequestSelectDevice | UiRequestUnexpectedDeviceMode | UiRequestSelectAccount | UiRequestSelectFee | UpdateCustomFee | BundleProgress<any> | FirmwareProgress | FirmwareException | UiRequestAddressValidation | UiRequestSetOperation;
+export interface FirmwareReconnect {
+    type: typeof UI_REQUEST.FIRMWARE_RECONNECT;
+    payload: {
+        device: Device;
+        disconnected: boolean;
+        method: 'manual' | 'auto' | 'wait';
+        target: 'normal' | 'bootloader';
+        i: number;
+    };
+}
+export type UiEvent = UiRequestWithoutPayload | UiRequestDeviceAction | UiRequestButton | UiRequestPermission | UiRequestConfirmation | UiRequestSelectDevice | UiRequestUnexpectedDeviceMode | UiRequestSelectAccount | UiRequestSelectFee | UpdateCustomFee | BundleProgress<any> | FirmwareProgress | FirmwareException | FirmwareReconnect | UiRequestAddressValidation | UiRequestSetOperation;
 export type UiEventMessage = UiEvent & {
     event: typeof UI_EVENT;
 };

package/lib/events/ui-request.js

@@ -15,6 +15,7 @@ exports.UI_REQUEST = {
     FIRMWARE_NOT_COMPATIBLE: 'ui-device_firmware_not_compatible',
     FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
     FIRMWARE_PROGRESS: 'ui-firmware-progress',
+    FIRMWARE_RECONNECT: 'ui-firmware_reconnect',
     DEVICE_NEEDS_BACKUP: 'ui-device_needs_backup',
     REQUEST_UI_WINDOW: 'ui-request_window',
     CLOSE_UI_WINDOW: 'ui-close_window',

package/lib/index.js

@@ -21,11 +21,11 @@ const manifest = (data) => {
         manifest: data,
     });
 };
-const dispose = async () => {
+const dispose = () => {
     exports.eventEmitter.removeAllListeners();
     _settings = (0, connectSettings_1.parseConnectSettings)();
     if (_core) {
-        await _core.dispose();
+        _core.dispose();
         _core = null;
     }
 };

package/lib/types/api/backupDevice.d.ts

@@ -1,4 +1,4 @@
 import type { PROTO } from '../../constants';
-import type { CommonParams, Response } from '../params';
-export declare function backupDevice(params?: CommonParams): Response<PROTO.Success>;
+import type { Params, Response } from '../params';
+export declare function backupDevice(params?: Params<PROTO.BackupDevice>): Response<PROTO.Success>;
 //# sourceMappingURL=backupDevice.d.ts.map

package/lib/types/api/dispose.d.ts

@@ -1,2 +1,2 @@
-export declare function dispose(): Promise<void>;
+export declare function dispose(): void;
 //# sourceMappingURL=dispose.d.ts.map

package/lib/types/api/firmwareUpdate.d.ts

@@ -3,16 +3,17 @@ import type { Params, Response } from '../params';
 export type FirmwareUpdate = Static<typeof FirmwareUpdate>;
 export declare const FirmwareUpdate: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
     binary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
-    version: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
     btcOnly: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     baseUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    intermediaryVersion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<1>, import("@sinclair/typebox").TLiteral<2>, import("@sinclair/typebox").TLiteral<3>]>>;
+    language: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>, import("@sinclair/typebox").TObject<{
     binary: import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer;
 }>]>;
-export interface FirmwareUpdateResponse {
-    hash: string;
-    challenge: string;
-}
+export type FirmwareUpdateResponse = {
+    check: 'mismatch' | 'valid' | 'omitted';
+} | {
+    check: 'other-error';
+    checkError: string;
+};
 export declare function firmwareUpdate(params: Params<FirmwareUpdate>): Response<FirmwareUpdateResponse>;
 //# sourceMappingURL=firmwareUpdate.d.ts.map

package/lib/types/api/firmwareUpdate.js

@@ -2,14 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirmwareUpdate = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
-const firmware_1 = require("../firmware");
 exports.FirmwareUpdate = schema_utils_1.Type.Union([
     schema_utils_1.Type.Object({
         binary: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
-        version: schema_utils_1.Type.Array(schema_utils_1.Type.Number(), { minItems: 3, maxItems: 3 }),
         btcOnly: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
         baseUrl: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-        intermediaryVersion: schema_utils_1.Type.Optional(firmware_1.IntermediaryVersion),
+        language: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
     }),
     schema_utils_1.Type.Object({
         binary: schema_utils_1.Type.ArrayBuffer(),

package/lib/types/index.d.ts

@@ -19,5 +19,5 @@ export type { ComposeOutput, PrecomposeResultError, PrecomposeResultNonFinal, Pr
 export type { PrecomposedTransactionCardano, PrecomposedTransactionErrorCardano, PrecomposedTransactionFinalCardano, PrecomposedTransactionNonFinalCardano, } from './api/cardanoComposeTransaction';
 export type { RecoveryDevice } from './api/recoveryDevice';
 export type { AuthenticateDeviceResult } from './api/authenticateDevice';
-export type { TokenInfo, TokenTransfer, InternalTransfer, FiatRatesLegacy, Target as TransactionTarget, AccountBalanceHistory as BlockchainAccountBalanceHistory, } from '@trezor/blockchain-link';
+export type { TokenInfo, TokenTransfer, InternalTransfer, FiatRatesBySymbol, Target as TransactionTarget, AccountBalanceHistory as BlockchainAccountBalanceHistory, } from '@trezor/blockchain-link';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/settings.d.ts

@@ -15,7 +15,7 @@ export interface ConnectSettings {
     popup?: boolean;
     transportReconnect?: boolean;
     webusb?: boolean;
-    transports?: (Transport['name'] | Transport)[];
+    transports?: (Transport['name'] | Transport | (new (...args: any[]) => Transport))[];
     pendingTransportEvent?: boolean;
     lazyLoad?: boolean;
     interactionTimeout?: number;

package/lib/utils/popupPromiseManager.d.ts

@@ -0,0 +1,8 @@
+export declare const createPopupPromiseManager: () => {
+    wait: () => Promise<void>;
+    isWaiting: () => boolean;
+    clear: () => void;
+    resolve: () => void;
+    reject: (error: Error) => void;
+};
+//# sourceMappingURL=popupPromiseManager.d.ts.map

package/lib/utils/popupPromiseManager.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPopupPromiseManager = void 0;
+const utils_1 = require("@trezor/utils");
+const createPopupPromiseManager = () => {
+    let _popupPromise;
+    const ensure = () => _popupPromise !== null && _popupPromise !== void 0 ? _popupPromise : (_popupPromise = (0, utils_1.createDeferred)());
+    const wait = () => ensure().promise;
+    const resolve = () => ensure().resolve();
+    const isWaiting = () => !!_popupPromise;
+    const reject = (error) => {
+        _popupPromise === null || _popupPromise === void 0 ? void 0 : _popupPromise.reject(error);
+        _popupPromise = undefined;
+    };
+    const clear = () => {
+        _popupPromise = undefined;
+    };
+    return { wait, isWaiting, clear, resolve, reject };
+};
+exports.createPopupPromiseManager = createPopupPromiseManager;
+//# sourceMappingURL=popupPromiseManager.js.map

package/lib/utils/uiPromiseManager.d.ts

@@ -0,0 +1,38 @@
+import { UiPromiseCreator, UiPromiseResponse } from '../events';
+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;
+    get: <T extends "device-disconnect" | "popup-handshake" | "ui-receive_permission" | "ui-receive_confirmation" | "ui-receive_pin" | "ui-receive_passphrase" | "ui-receive_device" | "ui-receive_account" | "ui-receive_fee" | "ui-receive_word" | "ui-invalid_passphrase_action" | "ui-login_challenge_response">(type: T) => Promise<Extract<import("../events").UiResponsePopupHandshake, {
+        type: T;
+    }> | Extract<import("../events").UiResponsePermission, {
+        type: T;
+    }> | Extract<import("../events").UiResponseConfirmation, {
+        type: T;
+    }> | Extract<import("../events").UiResponseDevice, {
+        type: T;
+    }> | Extract<import("../events").UiResponsePin, {
+        type: T;
+    }> | Extract<import("../events").UiResponseWord, {
+        type: T;
+    }> | Extract<import("../events").UiResponsePassphrase, {
+        type: T;
+    }> | Extract<import("../events").UiResponsePassphraseAction, {
+        type: T;
+    }> | Extract<import("../events").UiResponseAccount, {
+        type: T;
+    }> | Extract<import("../events").UiResponseFee, {
+        type: T;
+    }> | Extract<import("../events").UiResponseLoginChallenge, {
+        type: T;
+    }> | Extract<{
+        type: "device-disconnect";
+        payload?: undefined;
+    }, {
+        type: T;
+    }>>;
+    clear: () => void;
+};
+//# sourceMappingURL=uiPromiseManager.d.ts.map

package/lib/utils/uiPromiseManager.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUiPromiseManager = void 0;
+const events_1 = require("../events");
+const utils_1 = require("@trezor/utils");
+const createUiPromiseManager = (interactionTimeout) => {
+    let _uiPromises = [];
+    const exists = (type) => _uiPromises.some(p => p.id === type);
+    const create = (promiseEvent, device) => {
+        const uiPromise = {
+            ...(0, utils_1.createDeferred)(promiseEvent),
+            device,
+        };
+        _uiPromises.push(uiPromise);
+        interactionTimeout();
+        return uiPromise;
+    };
+    const resolve = (event) => {
+        const uiPromise = _uiPromises.find(p => p.id === event.type);
+        if (!uiPromise)
+            return false;
+        uiPromise.resolve(event);
+        _uiPromises = _uiPromises.filter(p => p !== uiPromise);
+        return true;
+    };
+    const rejectAll = (error) => {
+        _uiPromises.forEach(p => p.reject(error));
+        _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; });
+        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; });
+    };
+    const get = (type) => {
+        var _a;
+        const uiPromise = _uiPromises.find(p => p.id === type);
+        return (_a = uiPromise === null || uiPromise === void 0 ? void 0 : uiPromise.promise) !== null && _a !== void 0 ? _a : Promise.reject(new Error(`UiPromise ${type} doesn't exist`));
+    };
+    const clear = () => {
+        _uiPromises = [];
+    };
+    return { exists, create, resolve, rejectAll, disconnected, get, clear };
+};
+exports.createUiPromiseManager = createUiPromiseManager;
+//# sourceMappingURL=uiPromiseManager.js.map

package/lib/workers/workers-browser.d.ts

@@ -1,7 +1,9 @@
 import BlockbookWorker from '@trezor/blockchain-link/lib/workers/blockbook';
 import RippleWorker from '@trezor/blockchain-link/lib/workers/ripple';
 import BlockfrostWorker from '@trezor/blockchain-link/lib/workers/blockfrost';
-import SolanaWorker from '@trezor/blockchain-link/lib/workers/solana';
+import type { BaseWorker } from '@trezor/blockchain-link/lib/workers/baseWorker';
+type WorkerAsyncImporter = () => Promise<BaseWorker<unknown>>;
+declare const SolanaWorker: WorkerAsyncImporter;
 declare const ElectrumWorker: undefined;
 export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker };
 //# sourceMappingURL=workers-browser.d.ts.map

package/lib/workers/workers-browser.js

@@ -8,8 +8,8 @@ const ripple_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/wo
 exports.RippleWorker = ripple_1.default;
 const blockfrost_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/blockfrost"));
 exports.BlockfrostWorker = blockfrost_1.default;
-const solana_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/solana"));
-exports.SolanaWorker = solana_1.default;
+const SolanaWorker = () => Promise.resolve().then(() => tslib_1.__importStar(require('@trezor/blockchain-link/lib/workers/solana'))).then(w => w.default());
+exports.SolanaWorker = SolanaWorker;
 const ElectrumWorker = undefined;
 exports.ElectrumWorker = ElectrumWorker;
 //# sourceMappingURL=workers-browser.js.map