@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/utils/formatUtils.d.ts

@@ -1,15 +1,13 @@
-import type { CoinInfo } from '../types';
+import type { CoinInfo } from '@trezor/connect-common';
 export declare const formatAmount: (n: string, coinInfo: CoinInfo) => string;
-export declare const formatTime: (n: number) => string;
 export declare const hasHexPrefix: (str: string) => boolean;
 export declare const stripHexPrefix: (str: string) => string;
 export declare const addHexPrefix: (str: string) => `0x${string}`;
-export declare const isHexString: (value: string, length?: number) => boolean;
+export declare const isHexString: (value: string) => false | RegExpMatchArray | null;
+export declare const messageToBuffer: (message: string) => Buffer<ArrayBuffer>;
 export declare const messageToHex: (message: string) => string;
 export declare const hexToText: (hex: string) => string;
 export declare const deepTransform: <V>(transform: (str: string) => V) => <T>(value: T) => DeepTransformed<T, V>;
-type DeepTransformed<T, V> = T extends string ? V : T extends (infer U)[] ? DeepTransformed<U, V>[] : T extends object ? {
-    [K in keyof T]: DeepTransformed<T[K], V>;
-} : T;
-export {};
-//# sourceMappingURL=formatUtils.d.ts.map
+type DeepTransformed<T, V> = T extends string ? V : T extends (infer U)[] ? DeepTransformed<U, V>[] : T extends object ? { [K in keyof T]: DeepTransformed<T[K], V> } : T;
+export declare const sanitizeString: (value?: string) => string | undefined;
+export {};

package/lib/utils/formatUtils.js

@@ -1,68 +1,26 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.deepTransform = exports.hexToText = exports.messageToHex = exports.isHexString = exports.addHexPrefix = exports.stripHexPrefix = exports.hasHexPrefix = exports.formatTime = exports.formatAmount = void 0;
-const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
-const formatAmount = (n, coinInfo) => `${new bigNumber_1.BigNumber(n).div(10 ** coinInfo.decimals).toString(10)} ${coinInfo.shortcut}`;
-exports.formatAmount = formatAmount;
-const formatTime = n => {
-  if (!n || n <= 0) return 'No time estimate';
-  const hours = Math.floor(n / 60);
-  const minutes = n % 60;
-  let res = '';
-  if (hours !== 0) {
-    res += `${hours} hour`;
-    if (hours > 1) {
-      res += 's';
-    }
-    res += ' ';
-  }
-  if (minutes !== 0) {
-    res += `${minutes} minutes`;
-  }
-  return res;
-};
-exports.formatTime = formatTime;
-const hasHexPrefix = str => str.slice(0, 2).toLowerCase() === '0x';
-exports.hasHexPrefix = hasHexPrefix;
-const stripHexPrefix = str => (0, exports.hasHexPrefix)(str) ? str.slice(2) : str;
-exports.stripHexPrefix = stripHexPrefix;
-const addHexPrefix = str => str !== undefined && !(0, exports.hasHexPrefix)(str) ? `0x${str}` : str;
-exports.addHexPrefix = addHexPrefix;
-const isHexString = (value, length) => {
-  if (typeof value !== 'string' || !value.match(/^(0x|0X)?[0-9A-Fa-f]*$/)) {
-    return false;
-  }
-  if (length && value.length !== 2 + 2 * length) {
-    return false;
-  }
-  return true;
-};
-exports.isHexString = isHexString;
-const messageToHex = message => {
-  let buffer;
-  if ((0, exports.isHexString)(message)) {
-    let clean = (0, exports.stripHexPrefix)(message);
+import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
+export const formatAmount = (n, coinInfo) => `${new BigNumber(n).div(10 ** coinInfo.decimals).toString(10)} ${coinInfo.shortcut}`;
+export const hasHexPrefix = str => str.slice(0, 2).toLowerCase() === '0x';
+export const stripHexPrefix = str => hasHexPrefix(str) ? str.slice(2) : str;
+export const addHexPrefix = str => str !== undefined && !hasHexPrefix(str) ? `0x${str}` : str;
+export const isHexString = value => typeof value === 'string' && value.match(/^(0x|0X)?[0-9A-Fa-f]*$/);
+export const messageToBuffer = message => {
+  if (isHexString(message)) {
+    let clean = stripHexPrefix(message);
     if (clean.length % 2 !== 0) {
       clean = `0${clean}`;
     }
-    buffer = Buffer.from(clean, 'hex');
+    return Buffer.from(clean, 'hex');
   } else {
-    buffer = Buffer.from(message);
+    return Buffer.from(message, 'utf8');
   }
-  return buffer.toString('hex');
 };
-exports.messageToHex = messageToHex;
-const hexToText = hex => {
-  const clean = (0, exports.messageToHex)(hex);
-  const text = Buffer.from(clean, 'hex').toString('utf8');
-  if (/[\uFFFD]/.test(text)) return hex;
-  return text;
+export const messageToHex = message => messageToBuffer(message).toString('hex');
+export const hexToText = hex => {
+  const text = messageToBuffer(hex).toString('utf8');
+  return /[\uFFFD]/.test(text) ? hex : text;
 };
-exports.hexToText = hexToText;
-const deepTransform = transform => {
+export const deepTransform = transform => {
   const recursion = value => {
     if (typeof value === 'string') {
       return transform(value);
@@ -80,5 +38,8 @@ const deepTransform = transform => {
   };
   return recursion;
 };
-exports.deepTransform = deepTransform;
-//# sourceMappingURL=formatUtils.js.map
+export const sanitizeString = value => {
+  if (typeof value === 'string') {
+    return value.replace(/[\u2018\u2019]/g, "'");
+  }
+};

package/lib/utils/hdnodeUtils.d.ts

@@ -1,7 +1,6 @@
+import type { PROTO } from '@trezor/connect-common';
 import type { Network } from '@trezor/utxo-lib';
-import { PROTO } from '../constants';
 export declare const convertXpub: (xpub: string, originalNetwork?: Network, requestedNetwork?: Network) => string;
 export declare function xpubDerive<PK extends PROTO.PublicKey | PROTO.EthereumPublicKey>(xpub: PK, childXPub: PK, suffix: number, network?: Network, _requestedNetwork?: Network): PK;
 export declare const xpubToHDNodeType: (xpub: string, network: Network) => PROTO.HDNodeType;
-export declare const convertMultisigPubKey: <T extends PROTO.TxInputType | PROTO.TxOutputType>(network: Network, utxo: T) => T;
-//# sourceMappingURL=hdnodeUtils.d.ts.map
+export declare const convertMultisigPubKey: <T extends PROTO.TxInputType | PROTO.TxOutputType>(network: Network, utxo: T) => T;

package/lib/utils/hdnodeUtils.js

@@ -1,36 +1,28 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.convertMultisigPubKey = exports.xpubToHDNodeType = exports.convertXpub = void 0;
-exports.xpubDerive = xpubDerive;
-const utxo_lib_1 = require("@trezor/utxo-lib");
-const constants_1 = require("../constants");
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { bip32 } from "@trezor/utxo-lib";
 const pubNode2bjsNode = (node, network) => {
   const chainCode = Buffer.from(node.chain_code, 'hex');
   const publicKey = Buffer.from(node.public_key, 'hex');
-  const res = utxo_lib_1.bip32.fromPublicKey(publicKey, chainCode, network);
+  const res = bip32.fromPublicKey(publicKey, chainCode, network);
   res.__DEPTH = node.depth;
   res.__INDEX = node.child_num;
   res.__PARENT_FINGERPRINT = node.fingerprint;
   return res;
 };
-const convertXpub = (xpub, originalNetwork, requestedNetwork) => {
-  const node = utxo_lib_1.bip32.fromBase58(xpub, originalNetwork);
+export const convertXpub = (xpub, originalNetwork, requestedNetwork) => {
+  const node = bip32.fromBase58(xpub, originalNetwork);
   if (requestedNetwork) {
     node.network = requestedNetwork;
   }
   return node.toBase58();
 };
-exports.convertXpub = convertXpub;
 const pubKey2bjsNode = (key, network) => {
   const keyNode = key.node;
   const bjsNode = pubNode2bjsNode(keyNode, network);
   const bjsXpub = bjsNode.toBase58();
-  const keyXpub = (0, exports.convertXpub)(key.xpub, network);
+  const keyXpub = convertXpub(key.xpub, network);
   if (bjsXpub !== keyXpub) {
-    throw constants_1.ERRORS.TypedError('Runtime', `pubKey2bjsNode: Invalid public key transmission detected. Key: ${bjsXpub}, Received: ${keyXpub}`);
+    throw ERRORS.TypedError('Runtime', `pubKey2bjsNode: Invalid public key transmission detected. Key: ${bjsXpub}, Received: ${keyXpub}`);
   }
   return bjsNode;
 };
@@ -39,17 +31,17 @@ const checkDerivation = (parBjsNode, childBjsNode, suffix) => {
   const derivedXpub = derivedChildBjsNode.toBase58();
   const compXpub = childBjsNode.toBase58();
   if (derivedXpub !== compXpub) {
-    throw constants_1.ERRORS.TypedError('Runtime', `checkDerivation: Invalid child cross-check public key. Derived: ${derivedXpub}, Received: ${compXpub}`);
+    throw ERRORS.TypedError('Runtime', `checkDerivation: Invalid child cross-check public key. Derived: ${derivedXpub}, Received: ${compXpub}`);
   }
 };
-function xpubDerive(xpub, childXPub, suffix, network, _requestedNetwork) {
+export function xpubDerive(xpub, childXPub, suffix, network, _requestedNetwork) {
   const resNode = pubKey2bjsNode(xpub, network);
   const childNode = pubKey2bjsNode(childXPub, network);
   checkDerivation(resNode, childNode, suffix);
   return xpub;
 }
-const xpubToHDNodeType = (xpub, network) => {
-  const hd = utxo_lib_1.bip32.fromBase58(xpub, network);
+export const xpubToHDNodeType = (xpub, network) => {
+  const hd = bip32.fromBase58(xpub, network);
   return {
     depth: hd.depth,
     child_num: hd.index,
@@ -58,16 +50,13 @@ const xpubToHDNodeType = (xpub, network) => {
     chain_code: hd.chainCode.toString('hex')
   };
 };
-exports.xpubToHDNodeType = xpubToHDNodeType;
-const convertMultisigPubKey = (network, utxo) => {
+export const convertMultisigPubKey = (network, utxo) => {
   if ('multisig' in utxo && utxo.multisig?.pubkeys) {
     utxo.multisig.pubkeys.forEach(pk => {
       if (typeof pk.node === 'string') {
-        pk.node = (0, exports.xpubToHDNodeType)(pk.node, network);
+        pk.node = xpubToHDNodeType(pk.node, network);
       }
     });
   }
   return utxo;
-};
-exports.convertMultisigPubKey = convertMultisigPubKey;
-//# sourceMappingURL=hdnodeUtils.js.map
+};

package/lib/utils/pathUtils.d.ts

@@ -1,21 +1 @@
-import { PROTO } from '../constants';
-import type { CoinInfo } from '../types/coinInfo';
-import type { DerivationPath, ProtoWithAddressN, ProtoWithDerivationPath } from '../types/params';
-export declare const HD_HARDENED = 2147483648;
-export declare const toHardened: (n: number) => number;
-export declare const fromHardened: (n: number) => number;
-export declare const getSlip44ByPath: (path: number[]) => number;
-export declare const getHDPath: (path: string) => number[];
-export declare const isSegwitPath: (path: number[] | undefined) => boolean;
-export declare const isBech32Path: (path: number[] | undefined) => boolean;
-export declare const isTaprootPath: (path: number[] | undefined) => boolean;
-export declare const getAccountType: (path: number[] | undefined) => "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
-export declare const getScriptType: (path: number[] | undefined) => PROTO.InternalInputScriptType | undefined;
-export declare const getOutputScriptType: (path?: number[]) => PROTO.ChangeOutputScriptType | undefined;
-export declare const validatePath: (path: DerivationPath, length?: number, base?: boolean) => number[];
-export declare const getSerializedPath: (path: number[]) => string;
-export declare const getPathFromIndex: (bip44purpose: number, bip44cointype: number, index: number) => number[];
-export declare const getIndexFromPath: (path: number[]) => number;
-export declare const fixPath: <T extends ProtoWithDerivationPath<PROTO.TxInputType> | ProtoWithDerivationPath<PROTO.TxOutputType>>(utxo: T) => ProtoWithAddressN<T>;
-export declare const getLabel: (label: string, coinInfo?: CoinInfo) => string;
-//# sourceMappingURL=pathUtils.d.ts.map
+export * from '@trezor/connect-common/lib/utils/pathUtils';

package/lib/utils/pathUtils.js

@@ -1,172 +1 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getLabel = exports.fixPath = exports.getIndexFromPath = exports.getPathFromIndex = exports.getSerializedPath = exports.validatePath = exports.getOutputScriptType = exports.getScriptType = exports.getAccountType = exports.isTaprootPath = exports.isBech32Path = exports.isSegwitPath = exports.getHDPath = exports.getSlip44ByPath = exports.fromHardened = exports.toHardened = exports.HD_HARDENED = void 0;
-const constants_1 = require("../constants");
-exports.HD_HARDENED = 0x80000000;
-const toHardened = n => (n | exports.HD_HARDENED) >>> 0;
-exports.toHardened = toHardened;
-const fromHardened = n => (n & ~exports.HD_HARDENED) >>> 0;
-exports.fromHardened = fromHardened;
-const getSlip44ByPath = path => (0, exports.fromHardened)(path[1]);
-exports.getSlip44ByPath = getSlip44ByPath;
-const PATH_NOT_VALID = constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Not a valid path');
-const PATH_NEGATIVE_VALUES = constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Path cannot contain negative values');
-const getHDPath = path => {
-  const parts = path.toLowerCase().split('/');
-  if (parts[0] !== 'm') throw PATH_NOT_VALID;
-  return parts.filter(p => p !== 'm' && p !== '').map(p => {
-    let hardened = false;
-    if (p.endsWith("'")) {
-      hardened = true;
-      p = p.substring(0, p.length - 1);
-    }
-    let n = parseInt(p, 10);
-    if (Number.isNaN(n)) {
-      throw PATH_NOT_VALID;
-    } else if (n < 0) {
-      throw PATH_NEGATIVE_VALUES;
-    }
-    if (hardened) {
-      n = (0, exports.toHardened)(n);
-    }
-    return n;
-  });
-};
-exports.getHDPath = getHDPath;
-const isSegwitPath = path => Array.isArray(path) && path[0] === (0, exports.toHardened)(49);
-exports.isSegwitPath = isSegwitPath;
-const isBech32Path = path => Array.isArray(path) && path[0] === (0, exports.toHardened)(84);
-exports.isBech32Path = isBech32Path;
-const isTaprootPath = path => Array.isArray(path) && (path[0] === (0, exports.toHardened)(86) || path[0] === (0, exports.toHardened)(10025));
-exports.isTaprootPath = isTaprootPath;
-const getAccountType = path => {
-  if ((0, exports.isTaprootPath)(path)) return 'p2tr';
-  if ((0, exports.isBech32Path)(path)) return 'p2wpkh';
-  if ((0, exports.isSegwitPath)(path)) return 'p2sh';
-  return 'p2pkh';
-};
-exports.getAccountType = getAccountType;
-const getScriptType = path => {
-  if (!Array.isArray(path) || path.length < 1) return undefined;
-  const p1 = (0, exports.fromHardened)(path[0]);
-  switch (p1) {
-    case 44:
-      return 'SPENDADDRESS';
-    case 48:
-      {
-        if (path.length < 4) return undefined;
-        const p3 = (0, exports.fromHardened)(path[3]);
-        switch (p3) {
-          case 0:
-            return 'SPENDMULTISIG';
-          case 1:
-            return 'SPENDP2SHWITNESS';
-          case 2:
-            return 'SPENDWITNESS';
-          default:
-            return undefined;
-        }
-      }
-    case 49:
-      return 'SPENDP2SHWITNESS';
-    case 84:
-      return 'SPENDWITNESS';
-    case 86:
-    case 10025:
-      return 'SPENDTAPROOT';
-    default:
-      return undefined;
-  }
-};
-exports.getScriptType = getScriptType;
-const getOutputScriptType = path => {
-  if (!Array.isArray(path) || path.length < 1) return undefined;
-  const p = (0, exports.fromHardened)(path[0]);
-  switch (p) {
-    case 44:
-      return 'PAYTOADDRESS';
-    case 48:
-      {
-        if (path.length < 4) return undefined;
-        const p3 = (0, exports.fromHardened)(path[3]);
-        switch (p3) {
-          case 0:
-            return 'PAYTOMULTISIG';
-          case 1:
-            return 'PAYTOP2SHWITNESS';
-          case 2:
-            return 'PAYTOWITNESS';
-          default:
-            return undefined;
-        }
-      }
-    case 49:
-      return 'PAYTOP2SHWITNESS';
-    case 84:
-      return 'PAYTOWITNESS';
-    case 86:
-    case 10025:
-      return 'PAYTOTAPROOT';
-    default:
-      return undefined;
-  }
-};
-exports.getOutputScriptType = getOutputScriptType;
-const validatePath = (path, length = 0, base = false) => {
-  let valid;
-  if (typeof path === 'string') {
-    valid = (0, exports.getHDPath)(path);
-  } else if (Array.isArray(path)) {
-    valid = path.map(p => {
-      const n = parseInt(p, 10);
-      if (Number.isNaN(n)) {
-        throw PATH_NOT_VALID;
-      } else if (n < 0) {
-        throw PATH_NEGATIVE_VALUES;
-      }
-      return n;
-    });
-  }
-  if (!valid) throw PATH_NOT_VALID;
-  if (length > 0 && valid.length < length) throw PATH_NOT_VALID;
-  return base ? valid.splice(0, 3) : valid;
-};
-exports.validatePath = validatePath;
-const getSerializedPath = path => `m/${path.map(i => {
-  const s = (i & ~exports.HD_HARDENED).toString();
-  if (i & exports.HD_HARDENED) {
-    return `${s}'`;
-  }
-  return s;
-}).join('/')}`;
-exports.getSerializedPath = getSerializedPath;
-const getPathFromIndex = (bip44purpose, bip44cointype, index) => [(0, exports.toHardened)(bip44purpose), (0, exports.toHardened)(bip44cointype), (0, exports.toHardened)(index)];
-exports.getPathFromIndex = getPathFromIndex;
-const getIndexFromPath = path => {
-  if (path.length < 3) {
-    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `getIndexFromPath: invalid path length ${path.toString()}`);
-  }
-  return (0, exports.fromHardened)(path[2]);
-};
-exports.getIndexFromPath = getIndexFromPath;
-const fixPath = utxo => {
-  if (utxo.address_n && Array.isArray(utxo.address_n)) {
-    utxo.address_n = utxo.address_n.map(i => i >>> 0);
-  }
-  if (utxo.address_n && typeof utxo.address_n === 'string') {
-    utxo.address_n = (0, exports.getHDPath)(utxo.address_n);
-  }
-  return utxo;
-};
-exports.fixPath = fixPath;
-const getLabel = (label, coinInfo) => {
-  if (coinInfo) {
-    return label.replace('#NETWORK', coinInfo.label);
-  }
-  return label.replace('#NETWORK', '');
-};
-exports.getLabel = getLabel;
-//# sourceMappingURL=pathUtils.js.map
+export * from "@trezor/connect-common/lib/utils/pathUtils.js";

package/lib/utils/paymentRequest.d.ts

@@ -0,0 +1,8 @@
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+export declare const PAYMENT_REQUEST_AMOUNT_BYTES: {
+  readonly DEFAULT: 8;
+  readonly EVM: 32;
+};
+export declare const encodePaymentRequestAmount: <T extends {
+  amount?: PROTO.PaymentRequest["amount"];
+}>(paymentRequest: T, bytesLength: number) => T;

package/lib/utils/paymentRequest.js

@@ -0,0 +1,25 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { formatBigUintToLE } from "@trezor/utils/lib/formatBigUintToLE.js";
+export const PAYMENT_REQUEST_AMOUNT_BYTES = {
+  DEFAULT: 8,
+  EVM: 32
+};
+export const encodePaymentRequestAmount = (paymentRequest, bytesLength) => {
+  if (paymentRequest.amount === undefined) {
+    return paymentRequest;
+  }
+  if (typeof paymentRequest.amount !== 'string' || !/^\d+$/.test(paymentRequest.amount)) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'Invalid PaymentRequest.amount: expected a decimal string in subunits');
+  }
+  try {
+    return {
+      ...paymentRequest,
+      amount: formatBigUintToLE({
+        value: paymentRequest.amount,
+        bytesLength
+      })
+    };
+  } catch (error) {
+    throw ERRORS.TypedError('Method_InvalidParameter', `Invalid PaymentRequest.amount: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};

package/lib/utils/uiPromiseManager.d.ts

@@ -1,43 +1,8 @@
-import { DEVICE, 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: DeviceUniquePath) => boolean;
-    get: <T extends UiPromiseResponse["type"]>(type: T) => Promise<Extract<import("../events").UiResponsePin, {
-        type: T;
-    }> | Extract<import("../events").UiResponsePassphrase, {
-        type: T;
-    }> | Extract<import("../events").UiResponseWord, {
-        type: T;
-    }> | Extract<import("../events").UiResponseThpPairingTag, {
-        type: T;
-    }> | Extract<import("../events").UiResponsePopupHandshake, {
-        type: T;
-    }> | Extract<import("../events").UiResponsePermission, {
-        type: T;
-    }> | Extract<import("../events").UiResponseConfirmation, {
-        type: T;
-    }> | Extract<import("../events").UiResponseFirmwares, {
-        type: T;
-    }> | Extract<import("../events").UiResponseDevice, {
-        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: typeof DEVICE.DISCONNECT;
-        payload?: undefined;
-    }, {
-        type: T;
-    }>>;
-    clear: () => void;
-};
-//# sourceMappingURL=uiPromiseManager.d.ts.map
+import type { UiPromiseCreator, UiPromiseResponse } from "../events/ui-promise.js";
+export declare const createUiPromiseManager: () => {
+  exists: (type: UiPromiseResponse["type"]) => boolean;
+  create: UiPromiseCreator;
+  resolve: (event: UiPromiseResponse) => boolean;
+  rejectAll: (error: Error) => void;
+  clear: () => void;
+};

package/lib/utils/uiPromiseManager.js

@@ -1,30 +1,34 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createUiPromiseManager = void 0;
-const utils_1 = require("@trezor/utils");
-const events_1 = require("../events");
-const createUiPromiseManager = interactionTimeout => {
+import { createDeferred } from "@trezor/utils";
+export const createUiPromiseManager = () => {
   let _uiPromises = [];
   const exists = type => _uiPromises.some(p => p.id === type);
   const create = (promiseEvent, device) => {
+    const requestId = crypto.randomUUID();
     const uiPromise = {
-      ...(0, utils_1.createDeferred)(promiseEvent),
-      device
+      ...createDeferred(promiseEvent),
+      device,
+      requestId
     };
-    const existing = _uiPromises.findIndex(p => p.id === promiseEvent);
+    const existing = _uiPromises.findIndex(p => p.id === promiseEvent && !p.requestId);
     if (existing >= 0) {
       console.warn(`UiPromise '${promiseEvent}' already exists.`);
       _uiPromises.splice(existing, 1);
     }
+    const {
+      reject
+    } = uiPromise;
+    uiPromise.reject = error => {
+      reject(error);
+      _uiPromises = _uiPromises.filter(p => p.requestId !== requestId);
+    };
     _uiPromises.push(uiPromise);
-    interactionTimeout();
     return uiPromise;
   };
   const resolve = event => {
-    const uiPromise = _uiPromises.find(p => p.id === event.type);
+    const uiPromise = _uiPromises.find(p => {
+      if (p.id !== event.type) return false;
+      return event.requestId == null || p.requestId === event.requestId;
+    });
     if (!uiPromise) return false;
     uiPromise.resolve(event);
     _uiPromises = _uiPromises.filter(p => p !== uiPromise);
@@ -34,18 +38,6 @@ const createUiPromiseManager = interactionTimeout => {
     _uiPromises.forEach(p => p.reject(error));
     _uiPromises = [];
   };
-  const disconnected = devicePath => {
-    const [toResolve, toKeep] = (0, utils_1.arrayPartition)(_uiPromises, p => p.device?.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 => p.device?.getUniquePath() === devicePath);
-  };
-  const get = type => {
-    const uiPromise = _uiPromises.find(p => p.id === type);
-    return uiPromise?.promise ?? Promise.reject(new Error(`UiPromise ${type} doesn't exist`));
-  };
   const clear = () => {
     _uiPromises = [];
   };
@@ -54,10 +46,6 @@ const createUiPromiseManager = interactionTimeout => {
     create,
     resolve,
     rejectAll,
-    disconnected,
-    get,
     clear
   };
-};
-exports.createUiPromiseManager = createUiPromiseManager;
-//# sourceMappingURL=uiPromiseManager.js.map
+};

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

@@ -0,0 +1,10 @@
+import type { BaseWorker } from '@trezor/blockchain-link/lib/workers/baseWorker';
+type WorkerAsyncImporter = () => Promise<BaseWorker<unknown>>;
+declare const BlockbookWorker: () => Worker;
+declare const BlockfrostWorker: () => Worker;
+declare const RippleWorker: () => Worker;
+declare const StellarWorker: () => Worker;
+declare const SolanaWorker: WorkerAsyncImporter;
+declare const ElectrumWorker: undefined;
+declare const EvmRpcWorker: WorkerAsyncImporter;
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, EvmRpcWorker };

package/lib/workers/workers.browser.js

@@ -0,0 +1,16 @@
+const BlockbookWorker = () => new Worker(new URL('@trezor/blockchain-link/src/workers/blockbook', import.meta.url), {
+  type: 'module'
+});
+const BlockfrostWorker = () => new Worker(new URL('@trezor/blockchain-link/src/workers/blockfrost', import.meta.url), {
+  type: 'module'
+});
+const RippleWorker = () => new Worker(new URL('@trezor/blockchain-link/src/workers/ripple', import.meta.url), {
+  type: 'module'
+});
+const StellarWorker = () => new Worker(new URL('@trezor/blockchain-link/src/workers/stellar', import.meta.url), {
+  type: 'module'
+});
+const SolanaWorker = () => import("@trezor/blockchain-link/lib/workers/solana").then(w => w.default());
+const ElectrumWorker = undefined;
+const EvmRpcWorker = () => import("@trezor/blockchain-link/lib/workers/evm-rpc").then(w => w.default());
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, EvmRpcWorker };

package/lib/workers/workers.d.ts

@@ -6,5 +6,5 @@ declare const BlockfrostWorker: WorkerAsyncImporter;
 declare const ElectrumWorker: WorkerAsyncImporter;
 declare const SolanaWorker: WorkerAsyncImporter;
 declare const StellarWorker: WorkerAsyncImporter;
-export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, };
-//# sourceMappingURL=workers.d.ts.map
+declare const EvmRpcWorker: WorkerAsyncImporter;
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, EvmRpcWorker };