@trezor/connect 9.0.0-beta.1

package/lib/utils/hdnodeUtils.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertMultisigPubKey = exports.xpubToHDNodeType = exports.xpubDerive = exports.convertBitcoinXpub = exports.convertXpub = void 0;
+const utxo_lib_1 = require("@trezor/utxo-lib");
+const constants_1 = require("../constants");
+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);
+    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);
+    if (requestedNetwork) {
+        node.network = requestedNetwork;
+    }
+    return node.toBase58();
+};
+exports.convertXpub = convertXpub;
+const convertBitcoinXpub = (xpub, network) => {
+    if (network.bip32.public === 0x0488b21e) {
+        return xpub;
+    }
+    const node = utxo_lib_1.bip32.fromBase58(xpub);
+    node.network = network;
+    return node.toBase58();
+};
+exports.convertBitcoinXpub = convertBitcoinXpub;
+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);
+    if (bjsXpub !== keyXpub) {
+        throw constants_1.ERRORS.TypedError('Runtime', `pubKey2bjsNode: Invalid public key transmission detected. Key: ${bjsXpub}, Received: ${keyXpub}`);
+    }
+    return bjsNode;
+};
+const checkDerivation = (parBjsNode, childBjsNode, suffix) => {
+    const derivedChildBjsNode = parBjsNode.derive(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}`);
+    }
+};
+function xpubDerive(xpub, childXPub, suffix, network, _requestedNetwork) {
+    const resNode = pubKey2bjsNode(xpub, network);
+    const childNode = pubKey2bjsNode(childXPub, network);
+    checkDerivation(resNode, childNode, suffix);
+    return xpub;
+}
+exports.xpubDerive = xpubDerive;
+const xpubToHDNodeType = (xpub, network) => {
+    const hd = utxo_lib_1.bip32.fromBase58(xpub, network);
+    return {
+        depth: hd.depth,
+        child_num: hd.index,
+        fingerprint: hd.parentFingerprint,
+        public_key: hd.publicKey.toString('hex'),
+        chain_code: hd.chainCode.toString('hex'),
+    };
+};
+exports.xpubToHDNodeType = xpubToHDNodeType;
+const convertMultisigPubKey = (network, utxo) => {
+    var _a;
+    if ('multisig' in utxo && ((_a = utxo.multisig) === null || _a === void 0 ? void 0 : _a.pubkeys)) {
+        utxo.multisig.pubkeys.forEach(pk => {
+            if (typeof pk.node === 'string') {
+                pk.node = (0, exports.xpubToHDNodeType)(pk.node, network);
+            }
+        });
+    }
+    return utxo;
+};
+exports.convertMultisigPubKey = convertMultisigPubKey;
+//# sourceMappingURL=hdnodeUtils.js.map

package/lib/utils/interactionTimeout.d.ts

@@ -0,0 +1,10 @@
+declare type TimeoutID = any;
+export declare class InteractionTimeout {
+    timeout?: TimeoutID | null;
+    seconds: number;
+    constructor(seconds?: number);
+    start(cancelFn: () => void, seconds?: number): void;
+    stop(): void;
+}
+export {};
+//# sourceMappingURL=interactionTimeout.d.ts.map

package/lib/utils/interactionTimeout.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionTimeout = void 0;
+const debug_1 = require("./debug");
+const _log = (0, debug_1.initLog)('InteractionTimeout');
+class InteractionTimeout {
+    constructor(seconds) {
+        this.timeout = null;
+        this.seconds = 0;
+        if (seconds) {
+            this.seconds = seconds;
+        }
+    }
+    start(cancelFn, seconds) {
+        const time = seconds || this.seconds;
+        if (time < 1) {
+            return;
+        }
+        this.stop();
+        _log.debug(`starting interaction timeout for ${time} seconds`);
+        this.timeout = setTimeout(() => {
+            _log.debug('interaction timed out');
+            cancelFn();
+        }, 1000 * time);
+    }
+    stop() {
+        if (this.timeout) {
+            _log.debug('clearing interaction timeout');
+            clearTimeout(this.timeout);
+        }
+    }
+}
+exports.InteractionTimeout = InteractionTimeout;
+//# sourceMappingURL=interactionTimeout.js.map

package/lib/utils/objectUtils.d.ts

@@ -0,0 +1,10 @@
+export declare function clone<T>(obj: T): T;
+export declare function entries<T>(obj: {
+    [key: string]: T;
+}): Array<[string, T]>;
+export declare function deepClone(_obj: any, _hash?: any): void;
+export declare function snapshot(obj: any): any;
+export declare function objectValues<X>(object: {
+    [key: string]: X;
+}): X[];
+//# sourceMappingURL=objectUtils.d.ts.map

package/lib/utils/objectUtils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectValues = exports.snapshot = exports.deepClone = exports.entries = exports.clone = void 0;
+function clone(obj) {
+    const jsonString = JSON.stringify(obj);
+    if (jsonString === undefined) {
+        return obj;
+    }
+    return JSON.parse(jsonString);
+}
+exports.clone = clone;
+function entries(obj) {
+    const keys = Object.keys(obj);
+    return keys.map(key => [key, obj[key]]);
+}
+exports.entries = entries;
+function deepClone(_obj, _hash = new WeakMap()) {
+}
+exports.deepClone = deepClone;
+function snapshot(obj) {
+    if (obj == null || typeof obj !== 'object') {
+        return obj;
+    }
+    const temp = new obj.constructor();
+    Object.keys(temp).forEach(key => {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            temp[key] = snapshot(obj[key]);
+        }
+    });
+    return temp;
+}
+exports.snapshot = snapshot;
+function objectValues(object) {
+    return Object.keys(object).map(key => object[key]);
+}
+exports.objectValues = objectValues;
+//# sourceMappingURL=objectUtils.js.map

package/lib/utils/pathUtils.d.ts

@@ -0,0 +1,20 @@
+import { PROTO } from '../constants';
+import type { CoinInfo } from '../types';
+export declare const HD_HARDENED = 2147483648;
+export declare const toHardened: (n: number) => number;
+export declare const fromHardened: (n: number) => number;
+export declare const getHDPath: (path: string) => number[];
+export declare const isMultisigPath: (path: number[] | undefined) => boolean;
+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) => "p2pkh" | "p2sh" | "p2tr" | "p2wpkh";
+export declare const getScriptType: (path: number[] | undefined) => PROTO.InternalInputScriptType;
+export declare const getOutputScriptType: (path?: number[] | undefined) => PROTO.ChangeOutputScriptType;
+export declare const validatePath: (path: string | number[], 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 PROTO.TxInputType | PROTO.TxOutputType>(utxo: T) => T;
+export declare const getLabel: (label: string, coinInfo?: CoinInfo | undefined) => string;
+//# sourceMappingURL=pathUtils.d.ts.map

package/lib/utils/pathUtils.js

@@ -0,0 +1,159 @@
+"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.isMultisigPath = exports.getHDPath = 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 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 isMultisigPath = (path) => Array.isArray(path) && path[0] === (0, exports.toHardened)(48);
+exports.isMultisigPath = isMultisigPath;
+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);
+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 'SPENDADDRESS';
+    const p1 = (0, exports.fromHardened)(path[0]);
+    switch (p1) {
+        case 48:
+            return 'SPENDMULTISIG';
+        case 49:
+            return 'SPENDP2SHWITNESS';
+        case 84:
+            return 'SPENDWITNESS';
+        case 86:
+            return 'SPENDTAPROOT';
+        default:
+            return 'SPENDADDRESS';
+    }
+};
+exports.getScriptType = getScriptType;
+const getOutputScriptType = (path) => {
+    if (!Array.isArray(path) || path.length < 1)
+        return 'PAYTOADDRESS';
+    if (path[0] === 49) {
+        return 'PAYTOP2SHWITNESS';
+    }
+    const p = (0, exports.fromHardened)(path[0]);
+    switch (p) {
+        case 48:
+            return 'PAYTOMULTISIG';
+        case 49:
+            return 'PAYTOP2SHWITNESS';
+        case 84:
+            return 'PAYTOWITNESS';
+        case 86:
+            return 'PAYTOTAPROOT';
+        default:
+            return 'PAYTOADDRESS';
+    }
+};
+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

package/lib/utils/promiseUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const resolveAfter: (msec: number, value?: any) => Promise<any>;
+//# sourceMappingURL=promiseUtils.d.ts.map

package/lib/utils/promiseUtils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAfter = void 0;
+const resolveAfter = (msec, value) => new Promise(resolve => {
+    setTimeout(resolve, msec, value);
+});
+exports.resolveAfter = resolveAfter;
+//# sourceMappingURL=promiseUtils.js.map

package/lib/utils/urlUtils.d.ts

@@ -0,0 +1,5 @@
+export declare const getOrigin: (url: string) => string;
+export declare const getOnionDomain: <T extends string | string[]>(url: T, dict: {
+    [domain: string]: string;
+}) => T;
+//# sourceMappingURL=urlUtils.d.ts.map

package/lib/utils/urlUtils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOnionDomain = exports.getOrigin = void 0;
+const getOrigin = (url) => {
+    if (typeof url !== 'string')
+        return 'unknown';
+    if (url.indexOf('file://') === 0)
+        return 'file://';
+    const parts = url.match(/^.+\:\/\/[^\/]+/);
+    return Array.isArray(parts) && parts.length > 0 ? parts[0] : 'unknown';
+};
+exports.getOrigin = getOrigin;
+const getOnionDomain = (url, dict) => {
+    var _a;
+    if (Array.isArray(url)) {
+        return url.map(u => (0, exports.getOnionDomain)(u, dict));
+    }
+    if (typeof url === 'string') {
+        const [, protocol, subdomain, domain, rest] = (_a = url.match(/^(http|ws)s?:\/\/([^:/]+\.)?([^/.]+\.[^/.]+)(\/.*)?$/i)) !== null && _a !== void 0 ? _a : [];
+        if (!domain || !dict[domain])
+            return url;
+        return `${protocol}://${subdomain || ''}${dict[domain]}${rest || ''}`;
+    }
+    return url;
+};
+exports.getOnionDomain = getOnionDomain;
+//# sourceMappingURL=urlUtils.js.map

package/lib/utils/versionUtils.d.ts

@@ -0,0 +1,6 @@
+export declare const isValidVersionString: (version: string) => boolean;
+export declare const isValidVersionArray: (version: number[]) => boolean;
+export declare const normalizeVersionArray: (version: number[]) => number[];
+export declare const versionSplit: (version: string) => number[];
+export declare const versionCompare: (a: string | number[], b: string | number[]) => 1 | 0 | -1;
+//# sourceMappingURL=versionUtils.d.ts.map

package/lib/utils/versionUtils.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionCompare = exports.versionSplit = exports.normalizeVersionArray = exports.isValidVersionArray = exports.isValidVersionString = void 0;
+const VER_NUMS = 3;
+const versionRegex = new RegExp(/^[0-9]{1,3}(\.[0-9]{1,3}){0,2}$/);
+const isValidVersionString = (version) => versionRegex.test(version);
+exports.isValidVersionString = isValidVersionString;
+const isValidVersionArray = (version) => {
+    if (!Array.isArray(version)) {
+        return false;
+    }
+    if (version.length === 0 || version.length > VER_NUMS) {
+        return false;
+    }
+    if (version[0] === 0) {
+        return false;
+    }
+    for (let i = 0; i < version.length; i++) {
+        if (typeof version[i] !== 'number' || version[i] < 0) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.isValidVersionArray = isValidVersionArray;
+const normalizeVersionArray = (version) => {
+    if (version.length === VER_NUMS) {
+        return version;
+    }
+    const partialVersion = [...version];
+    for (let i = version.length; i < VER_NUMS; i++) {
+        partialVersion.push(0);
+    }
+    return partialVersion;
+};
+exports.normalizeVersionArray = normalizeVersionArray;
+const versionSplit = (version) => {
+    if (!(0, exports.isValidVersionString)(version)) {
+        return [0, 0, 0];
+    }
+    return version.split('.').map(v => Number(v));
+};
+exports.versionSplit = versionSplit;
+const versionCompare = (a, b) => {
+    if (typeof a === 'string' && typeof b === 'string' && a === b) {
+        return 0;
+    }
+    const pa = typeof a === 'string' ? (0, exports.versionSplit)(a) : a;
+    const pb = typeof b === 'string' ? (0, exports.versionSplit)(b) : b;
+    const vpa = (0, exports.isValidVersionArray)(pa);
+    const vpb = (0, exports.isValidVersionArray)(pb);
+    if (!vpa && !vpb) {
+        return 0;
+    }
+    if (!vpa && vpb) {
+        return -1;
+    }
+    if (vpa && !vpb) {
+        return 1;
+    }
+    const npa = (0, exports.normalizeVersionArray)(pa);
+    const npb = (0, exports.normalizeVersionArray)(pb);
+    for (let i = 0; i < VER_NUMS; i++) {
+        if (npa[i] > npb[i])
+            return 1;
+        if (npb[i] > npa[i])
+            return -1;
+    }
+    return 0;
+};
+exports.versionCompare = versionCompare;
+//# sourceMappingURL=versionUtils.js.map

package/lib/utils/windowsUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const sendMessage: (message: any, origin: string) => void;
+//# sourceMappingURL=windowsUtils.d.ts.map

package/lib/utils/windowsUtils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessage = void 0;
+const sendMessage = (message, origin) => window.parent.postMessage(message, origin);
+exports.sendMessage = sendMessage;
+//# sourceMappingURL=windowsUtils.js.map

package/lib/workers/RNUsbPlugin.d.ts

@@ -0,0 +1,31 @@
+declare type TrezorDeviceInfoDebug = {
+    path: string;
+    debug: boolean;
+};
+interface TrezorTransport {
+    enumerate(): Promise<TrezorDeviceInfoDebug[]>;
+    acquire(path: string, debugLink: boolean): Promise<void>;
+    release(path: string, debugLink: boolean, closePort: boolean): Promise<void>;
+    write(path: string, debugLink: boolean, data: string): Promise<void>;
+    read(path: string, debugLink: boolean): Promise<{
+        data: string;
+    }>;
+}
+export declare class ReactNativePlugin {
+    name: string;
+    version: string;
+    debug: boolean;
+    allowsWriteAndEnumerate: boolean;
+    requestNeeded: boolean;
+    usb: TrezorTransport;
+    constructor();
+    init(debug?: boolean): Promise<void>;
+    enumerate(): Promise<TrezorDeviceInfoDebug[]>;
+    send(path: string, data: ArrayBuffer, debugLink: boolean): Promise<void>;
+    receive(path: string, debugLink: boolean): Promise<ArrayBuffer>;
+    connect(path: string, debugLink: boolean): Promise<void>;
+    disconnect(path: string, debugLink: boolean, last: boolean): Promise<void>;
+    requestDevice(): any;
+}
+export {};
+//# sourceMappingURL=RNUsbPlugin.d.ts.map

package/lib/workers/RNUsbPlugin.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactNativePlugin = void 0;
+const react_native_1 = require("react-native");
+const bufferToHex = (buffer) => Array.prototype.map.call(new Uint8Array(buffer), x => `00${x.toString(16)}`.slice(-2)).join('');
+const toArrayBuffer = (buffer) => {
+    const ab = new ArrayBuffer(buffer.length);
+    const view = new Uint8Array(ab);
+    const len = buffer.length;
+    for (let i = 0; i < len; ++i) {
+        view[i] = buffer[i];
+    }
+    return ab;
+};
+class ReactNativePlugin {
+    constructor() {
+        this.name = 'ReactNativePlugin';
+        this.version = '1.0.0';
+        this.debug = false;
+        this.allowsWriteAndEnumerate = true;
+        this.requestNeeded = false;
+        this.usb = react_native_1.NativeModules.TrezorTransport;
+    }
+    init(debug) {
+        this.debug = !!debug;
+        if (!this.usb) {
+            throw new Error('ReactNative plugin is not available');
+        }
+        return Promise.resolve();
+    }
+    enumerate() {
+        return this.usb.enumerate();
+    }
+    send(path, data, debugLink) {
+        const dataHex = bufferToHex(data);
+        return this.usb.write(path, debugLink, dataHex);
+    }
+    async receive(path, debugLink) {
+        const { data } = await this.usb.read(path, debugLink);
+        return toArrayBuffer(Buffer.from(data, 'hex'));
+    }
+    async connect(path, debugLink) {
+        for (let i = 0; i < 5; i++) {
+            if (i > 0) {
+                await new Promise(resolve => setTimeout(resolve, i * 200));
+            }
+            try {
+                await this.usb.acquire(path, debugLink);
+                return;
+            }
+            catch (e) {
+                if (i === 4) {
+                    throw e;
+                }
+            }
+        }
+    }
+    disconnect(path, debugLink, last) {
+        return this.usb.release(path, debugLink, last);
+    }
+    requestDevice() {
+    }
+}
+exports.ReactNativePlugin = ReactNativePlugin;
+//# sourceMappingURL=RNUsbPlugin.js.map

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

@@ -0,0 +1,8 @@
+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';
+declare const WebUsbPlugin: () => import("packages/transport/lib/lowlevel/withSharedConnections").default;
+declare const ReactNativeUsbPlugin: undefined;
+declare const ElectrumWorker: undefined;
+export { WebUsbPlugin, ReactNativeUsbPlugin, BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, };
+//# sourceMappingURL=workers-browser.d.ts.map

package/lib/workers/workers-browser.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElectrumWorker = exports.BlockfrostWorker = exports.RippleWorker = exports.BlockbookWorker = exports.ReactNativeUsbPlugin = exports.WebUsbPlugin = void 0;
+const tslib_1 = require("tslib");
+const sharedConnectionWorker_1 = (0, tslib_1.__importDefault)(require("@trezor/transport/lib/lowlevel/sharedConnectionWorker"));
+const blockbook_1 = (0, tslib_1.__importDefault)(require("@trezor/blockchain-link/lib/workers/blockbook"));
+exports.BlockbookWorker = blockbook_1.default;
+const ripple_1 = (0, tslib_1.__importDefault)(require("@trezor/blockchain-link/lib/workers/ripple"));
+exports.RippleWorker = ripple_1.default;
+const blockfrost_1 = (0, tslib_1.__importDefault)(require("@trezor/blockchain-link/lib/workers/blockfrost"));
+exports.BlockfrostWorker = blockfrost_1.default;
+const transport_1 = (0, tslib_1.__importDefault)(require("@trezor/transport"));
+const WebUsbPlugin = () => new transport_1.default.Lowlevel(new transport_1.default.WebUsb(), typeof SharedWorker !== 'undefined' ? () => new sharedConnectionWorker_1.default() : null);
+exports.WebUsbPlugin = WebUsbPlugin;
+const ReactNativeUsbPlugin = undefined;
+exports.ReactNativeUsbPlugin = ReactNativeUsbPlugin;
+const ElectrumWorker = undefined;
+exports.ElectrumWorker = ElectrumWorker;
+//# sourceMappingURL=workers-browser.js.map

package/lib/workers/workers-react-native.d.ts

@@ -0,0 +1,8 @@
+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';
+declare const WebUsbPlugin: undefined;
+declare const ElectrumWorker: undefined;
+declare const ReactNativeUsbPlugin: () => import("packages/transport/lib/lowlevel/withSharedConnections").default;
+export { WebUsbPlugin, ReactNativeUsbPlugin, BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, };
+//# sourceMappingURL=workers-react-native.d.ts.map

package/lib/workers/workers-react-native.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElectrumWorker = exports.BlockfrostWorker = exports.RippleWorker = exports.BlockbookWorker = exports.ReactNativeUsbPlugin = exports.WebUsbPlugin = void 0;
+const tslib_1 = require("tslib");
+const blockbook_1 = (0, tslib_1.__importDefault)(require("@trezor/blockchain-link/lib/workers/blockbook"));
+exports.BlockbookWorker = blockbook_1.default;
+const ripple_1 = (0, tslib_1.__importDefault)(require("@trezor/blockchain-link/lib/workers/ripple"));
+exports.RippleWorker = ripple_1.default;
+const blockfrost_1 = (0, tslib_1.__importDefault)(require("@trezor/blockchain-link/lib/workers/blockfrost"));
+exports.BlockfrostWorker = blockfrost_1.default;
+const transport_1 = (0, tslib_1.__importDefault)(require("@trezor/transport"));
+const RNUsbPlugin_1 = require("./RNUsbPlugin");
+const WebUsbPlugin = undefined;
+exports.WebUsbPlugin = WebUsbPlugin;
+const ElectrumWorker = undefined;
+exports.ElectrumWorker = ElectrumWorker;
+const ReactNativeUsbPlugin = () => new transport_1.default.Lowlevel(new RNUsbPlugin_1.ReactNativePlugin(), undefined);
+exports.ReactNativeUsbPlugin = ReactNativeUsbPlugin;
+//# sourceMappingURL=workers-react-native.js.map

package/lib/workers/workers.d.ts

@@ -0,0 +1,10 @@
+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 ElectrumWorker from '@trezor/blockchain-link/lib/workers/electrum';
+import type { Transport } from '@trezor/transport';
+declare type TransportWrapper = () => Transport;
+declare const WebUsbPlugin: TransportWrapper | typeof undefined;
+declare const ReactNativeUsbPlugin: TransportWrapper | typeof undefined;
+export { WebUsbPlugin, ReactNativeUsbPlugin, BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, };
+//# sourceMappingURL=workers.d.ts.map