@trezor/connect 9.4.7 → 9.4.8-beta.1

package/lib/device/DeviceList.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceList = exports.assertDeviceListConnected = void 0;
-const utils_1 = require("@trezor/utils");
 const transport_1 = require("@trezor/transport");
+const utils_1 = require("@trezor/utils");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const Device_1 = require("./Device");
-const types_1 = require("../types");
 const transportInfo_1 = require("../data/transportInfo");
-const debug_1 = require("../utils/debug");
-const promiseUtils_1 = require("../utils/promiseUtils");
+const types_1 = require("../types");
 const utils_2 = require("../types/utils");
-const _log = (0, debug_1.initLog)('DeviceList');
+const abortablePromise_1 = require("../utils/abortablePromise");
+const debug_1 = require("../utils/debug");
 const createAuthPenaltyManager = (priority) => {
     const penalizedDevices = {};
     const get = () => 100 * priority +
@@ -32,22 +31,81 @@ const createAuthPenaltyManager = (priority) => {
     const clear = () => Object.keys(penalizedDevices).forEach(key => delete penalizedDevices[key]);
     return { get, add, remove, clear };
 };
+const createDeviceCollection = () => {
+    let devices = [];
+    const isEqual = (a) => (b) => a.transport === b.transport && a.transportPath === b.transportPath;
+    const get = (transportPath, transport) => devices.find(isEqual({ transport, transportPath }));
+    const all = () => devices;
+    const add = (device) => {
+        const index = devices.findIndex(isEqual(device));
+        if (index >= 0)
+            devices[index] = device;
+        else
+            devices.push(device);
+    };
+    const remove = (transportPath, transport) => {
+        const index = devices.findIndex(isEqual({ transport, transportPath }));
+        const [removed] = index >= 0 ? devices.splice(index, 1) : [undefined];
+        return removed;
+    };
+    const clear = (transport) => {
+        let removed;
+        [removed, devices] = (0, utils_1.arrayPartition)(devices, d => !transport || d.transport === transport);
+        return removed;
+    };
+    return { get, all, add, remove, clear };
+};
+const getTransportInfo = (transport) => ({
+    apiType: transport.apiType,
+    type: transport.name,
+    version: transport.version,
+    outdated: transport.isOutdated,
+});
 const assertDeviceListConnected = deviceList => {
-    if (!deviceList.isConnected())
+    if (!deviceList.isConnected()) {
         throw constants_1.ERRORS.TypedError('Transport_Missing');
+    }
 };
 exports.assertDeviceListConnected = assertDeviceListConnected;
 class DeviceList extends utils_1.TypedEmitter {
     isConnected() {
-        return !!this.transport;
+        return !!Object.keys(this.transport).length;
     }
     pendingConnection() {
-        return this.initPromise;
+        const pending = Object.values(this.locks)
+            .map(({ promise }) => promise)
+            .filter(utils_1.isNotUndefined);
+        if (pending.length)
+            return Promise.all(pending).then(() => { });
+    }
+    getActiveTransports() {
+        return Object.values(this.transport).map(getTransportInfo);
+    }
+    async transportLock(apiType, abortMessage, action) {
+        var _a, _b;
+        const lock = (_a = this.locks[apiType]) !== null && _a !== void 0 ? _a : (this.locks[apiType] = { sequence: 0 });
+        lock.abortMessage = abortMessage;
+        const sequence = ++lock.sequence;
+        while (lock.promise) {
+            (_b = lock.abort) === null || _b === void 0 ? void 0 : _b.abort(new Error(abortMessage));
+            await lock.promise.catch(() => { });
+        }
+        if (sequence !== lock.sequence)
+            return Promise.reject(new Error(lock.abortMessage));
+        lock.abort = new AbortController();
+        lock.promise = action(lock.abort.signal).finally(() => {
+            delete lock.abort;
+            delete lock.promise;
+        });
+        return lock.promise;
     }
     constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }) {
         super();
-        this.devices = {};
+        this.transport = {};
+        this.transports = [];
+        this.devices = createDeviceCollection();
         this.deviceCounter = Date.now();
+        this.locks = {};
         const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
         this.handshakeLock = (0, utils_1.getSynchronize)();
         this.authPenaltyManager = createAuthPenaltyManager(priority);
@@ -57,16 +115,17 @@ class DeviceList extends utils_1.TypedEmitter {
             sessionsBackgroundUrl: _sessionsBackgroundUrl,
             id: (manifest === null || manifest === void 0 ? void 0 : manifest.appUrl) || 'unknown app',
         };
-        this.transports = [
-            new transport_1.BridgeTransport({
-                latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
-                ...this.transportCommonArgs,
-            }),
-        ];
     }
-    createTransport(transportType) {
+    tryGetTransport(name) {
+        return this.transports.find(t => t.name === name);
+    }
+    getOrCreateTransport(transportType) {
+        var _a;
         const { transportCommonArgs } = this;
         if (typeof transportType === 'string') {
+            const existing = this.tryGetTransport(transportType);
+            if (existing)
+                return existing;
             switch (transportType) {
                 case 'WebUsbTransport':
                     return new transport_1.WebUsbTransport(transportCommonArgs);
@@ -84,10 +143,13 @@ class DeviceList extends utils_1.TypedEmitter {
         else if (typeof transportType === 'function' && 'prototype' in transportType) {
             const transportInstance = new transportType(transportCommonArgs);
             if ((0, transport_1.isTransportInstance)(transportInstance)) {
-                return transportInstance;
+                return (_a = this.tryGetTransport(transportInstance.name)) !== null && _a !== void 0 ? _a : transportInstance;
             }
         }
         else if ((0, transport_1.isTransportInstance)(transportType)) {
+            if (this.tryGetTransport(transportType.name)) {
+                return transportType;
+            }
             if (!transportType.getMessage()) {
                 transportType.updateMessages(transportCommonArgs.messages);
             }
@@ -95,185 +157,212 @@ class DeviceList extends utils_1.TypedEmitter {
         }
         throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
     }
-    setTransports(transports) {
+    createTransports(transports) {
         const transportTypes = (transports === null || transports === void 0 ? void 0 : transports.length) ? transports : ['BridgeTransport'];
-        this.transports = transportTypes.map(this.createTransport.bind(this));
+        return transportTypes.map(this.getOrCreateTransport.bind(this));
     }
     onDeviceConnected(descriptor, transport) {
-        const { path } = descriptor;
         const id = (this.deviceCounter++).toString(16).slice(-8);
         const device = new Device_1.Device({
             id: (0, types_1.DeviceUniquePath)(id),
             transport,
             descriptor,
-            listener: lifecycle => this.emit(lifecycle, device.toMessageObject()),
+            listener: lifecycle => this.emit(lifecycle, device),
         });
-        this.devices[path] = device;
+        this.devices.add(device);
         const penalty = this.authPenaltyManager.get();
         this.handshakeLock(async () => {
-            if (this.devices[path]) {
+            if (this.devices.get(descriptor.path, transport)) {
                 await device.handshake(penalty);
             }
         });
     }
-    onDeviceDisconnected(descriptor) {
-        const { path } = descriptor;
-        const device = this.devices[path];
-        if (device) {
-            device.disconnect();
-            delete this.devices[path];
-        }
+    onDeviceDisconnected(descriptor, transport) {
+        const device = this.devices.remove(descriptor.path, transport);
+        device === null || device === void 0 ? void 0 : device.disconnect();
     }
-    onDeviceSessionChanged(descriptor) {
-        const device = this.devices[descriptor.path];
-        if (device) {
-            device.updateDescriptor(descriptor);
-        }
+    onDeviceSessionChanged(descriptor, transport) {
+        const device = this.devices.get(descriptor.path, transport);
+        device === null || device === void 0 ? void 0 : device.updateDescriptor(descriptor);
     }
-    onDeviceRequestRelease(descriptor) {
-        var _a;
-        (_a = this.devices[descriptor.path]) === null || _a === void 0 ? void 0 : _a.usedElsewhere();
+    onDeviceRequestRelease(descriptor, transport) {
+        const device = this.devices.get(descriptor.path, transport);
+        device === null || device === void 0 ? void 0 : device.usedElsewhere();
     }
-    init(initParams = {}) {
-        if (!this.initPromise) {
-            _log.debug('Initializing transports');
-            this.initPromise = this.createInitPromise(initParams);
-        }
-        return this.initPromise;
+    async init(initParams = {}) {
+        this.transports = this.createTransports(initParams.transports);
+        const promises = this.transports
+            .map(t => t.apiType)
+            .concat((0, utils_2.typedObjectKeys)(this.transport))
+            .concat((0, utils_2.typedObjectKeys)(this.locks))
+            .filter(utils_1.arrayDistinct)
+            .map(apiType => this.transportLock(apiType, 'New init', signal => this.createInitPromise(apiType, initParams, signal)));
+        await Promise.all(promises);
     }
-    createInitPromise(initParams) {
-        return this.selectTransport(this.transports)
-            .then(transport => this.initializeTransport(transport, initParams))
-            .then(transport => {
-            this.transport = transport;
-            this.emit(transport_1.TRANSPORT.START, this.getTransportInfo());
-            this.initPromise = undefined;
-        })
-            .catch(error => {
-            this.cleanup();
-            this.emit(transport_1.TRANSPORT.ERROR, error);
-            this.initPromise = initParams.transportReconnect
-                ? this.createReconnectPromise(initParams)
+    async createInitPromise(apiType, initParams, abortSignal) {
+        try {
+            const transports = this.transports.filter(t => t.apiType === apiType);
+            const transport = transports.length
+                ? await this.selectTransport(transports, abortSignal)
                 : undefined;
-        });
+            const oldTransport = this.transport[apiType];
+            if (oldTransport !== transport) {
+                if (oldTransport) {
+                    delete this.transport[apiType];
+                    await this.stopTransport(oldTransport);
+                    if (!transport) {
+                        this.emit(transport_1.TRANSPORT.ERROR, { apiType, error: 'Transport disabled' });
+                    }
+                }
+                if (transport) {
+                    try {
+                        await this.initializeTransport(transport, initParams, abortSignal);
+                    }
+                    catch (error) {
+                        await this.stopTransport(transport);
+                        throw error;
+                    }
+                    transport.on(transport_1.TRANSPORT.ERROR, error => {
+                        this.emit(transport_1.TRANSPORT.ERROR, { apiType, error });
+                        this.transportLock(apiType, 'Transport error', async (signal) => {
+                            delete this.transport[apiType];
+                            await this.stopTransport(transport);
+                            if (initParams.transportReconnect) {
+                                await this.createReconnectDelay(signal);
+                                await this.createInitPromise(apiType, initParams, signal);
+                            }
+                        }).catch(() => { });
+                    });
+                    this.transport[apiType] = transport;
+                    this.emit(transport_1.TRANSPORT.START, getTransportInfo(transport));
+                }
+            }
+        }
+        catch (error) {
+            this.emit(transport_1.TRANSPORT.ERROR, { apiType, error: error === null || error === void 0 ? void 0 : error.message });
+            if (initParams.transportReconnect && !abortSignal.aborted) {
+                this.transportLock(apiType, 'Reconnecting', async (signal) => {
+                    await this.createReconnectDelay(signal);
+                    await this.createInitPromise(apiType, initParams, signal);
+                }).catch(() => { });
+            }
+        }
     }
-    createReconnectPromise(initParams) {
-        const { promise, reject } = (0, promiseUtils_1.resolveAfter)(1000, initParams);
-        this.rejectPending = reject;
-        return promise
-            .then(this.createInitPromise.bind(this))
-            .catch(() => { })
-            .finally(() => {
-            this.rejectPending = undefined;
-        });
+    createReconnectDelay(signal) {
+        const { promise, resolve } = (0, abortablePromise_1.abortablePromise)(signal);
+        const timeout = setTimeout(resolve, 1000);
+        return promise.finally(() => clearTimeout(timeout));
     }
-    async selectTransport([transport, ...rest]) {
-        const result = await transport.init();
+    async selectTransport([transport, ...rest], signal) {
+        if (signal.aborted)
+            throw new Error(signal.reason);
+        if (transport === this.transport[transport.apiType])
+            return transport;
+        const result = await transport.init({ signal });
         if (result.success)
             return transport;
         else if (rest.length)
-            return this.selectTransport(rest);
+            return this.selectTransport(rest, signal);
         else
             throw new Error(result.error);
     }
-    async initializeTransport(transport, initParams) {
+    async initializeTransport(transport, initParams, signal) {
         transport.on(transport_1.TRANSPORT.DEVICE_CONNECTED, d => this.onDeviceConnected(d, transport));
-        transport.on(transport_1.TRANSPORT.DEVICE_DISCONNECTED, this.onDeviceDisconnected.bind(this));
-        transport.on(transport_1.TRANSPORT.DEVICE_SESSION_CHANGED, this.onDeviceSessionChanged.bind(this));
-        transport.on(transport_1.TRANSPORT.DEVICE_REQUEST_RELEASE, this.onDeviceRequestRelease.bind(this));
-        transport.on(transport_1.TRANSPORT.ERROR, error => {
-            this.cleanup();
-            this.emit(transport_1.TRANSPORT.ERROR, error);
-            if (initParams.transportReconnect) {
-                this.initPromise = this.createReconnectPromise(initParams);
-            }
-        });
-        const enumerateResult = await transport.enumerate();
+        transport.on(transport_1.TRANSPORT.DEVICE_DISCONNECTED, d => this.onDeviceDisconnected(d, transport));
+        transport.on(transport_1.TRANSPORT.DEVICE_SESSION_CHANGED, d => this.onDeviceSessionChanged(d, transport));
+        transport.on(transport_1.TRANSPORT.DEVICE_REQUEST_RELEASE, d => this.onDeviceRequestRelease(d, transport));
+        const enumerateResult = await transport.enumerate({ signal });
         if (!enumerateResult.success) {
             throw new Error(enumerateResult.error);
         }
         const descriptors = enumerateResult.payload;
         const waitForDevicesPromise = initParams.pendingTransportEvent && descriptors.length
-            ? this.waitForDevices(descriptors.length, 10000)
+            ? this.waitForDevices(transport, descriptors, signal)
             : Promise.resolve();
         transport.handleDescriptorsChange(descriptors);
         transport.listen();
         await waitForDevicesPromise;
-        return transport;
     }
-    waitForDevices(deviceCount, autoResolveMs) {
-        const { promise, resolve, reject } = (0, utils_1.createDeferred)();
-        let transportStartPending = deviceCount;
-        const autoResolveTransportEventTimeout = setTimeout(resolve, autoResolveMs);
-        this.rejectPending = reject;
-        const onDeviceConnect = () => {
-            transportStartPending--;
-            if (transportStartPending === 0) {
+    waitForDevices(transport, descriptors, signal) {
+        const { promise, reject, resolve } = (0, utils_1.createDeferred)();
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort);
+        const onError = (error) => reject(new Error(error));
+        transport.once(transport_1.TRANSPORT.ERROR, onError);
+        const autoResolveTransportEventTimeout = setTimeout(resolve, 10000);
+        const remaining = descriptors.slice();
+        const onDeviceEvent = (device) => {
+            const index = remaining.findIndex(d => d.path === device.transportPath && transport === device.transport);
+            if (index >= 0)
+                remaining.splice(index, 1);
+            if (!remaining.length)
                 resolve();
-            }
         };
-        this.on(events_1.DEVICE.CONNECT, onDeviceConnect);
-        this.on(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceConnect);
+        this.on(events_1.DEVICE.CONNECT, onDeviceEvent);
+        this.on(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceEvent);
+        this.on(events_1.DEVICE.DISCONNECT, onDeviceEvent);
         return promise.finally(() => {
-            this.rejectPending = undefined;
+            transport.off(transport_1.TRANSPORT.ERROR, onError);
+            signal.removeEventListener('abort', onAbort);
             clearTimeout(autoResolveTransportEventTimeout);
-            this.off(events_1.DEVICE.CONNECT, onDeviceConnect);
-            this.off(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceConnect);
+            this.off(events_1.DEVICE.CONNECT, onDeviceEvent);
+            this.off(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceEvent);
+            this.off(events_1.DEVICE.DISCONNECT, onDeviceEvent);
         });
     }
     getDeviceCount() {
-        return Object.keys(this.devices).length;
+        return this.devices.all().length;
     }
     getAllDevices() {
-        return (0, utils_2.typedObjectKeys)(this.devices).map(key => this.devices[key]);
+        return this.devices.all();
     }
     getOnlyDevice() {
-        return this.getDeviceCount() === 1 ? Object.values(this.devices)[0] : undefined;
+        return this.getDeviceCount() === 1 ? this.devices.all()[0] : undefined;
     }
     getDeviceByPath(path) {
-        return this.getAllDevices().find(d => d.getUniquePath() === path);
+        return this.devices.all().find(d => d.getUniquePath() === path);
     }
     getDeviceByStaticState(state) {
         const deviceId = state.split('@')[1].split(':')[0];
-        return this.getAllDevices().find(d => { var _a; return ((_a = d.features) === null || _a === void 0 ? void 0 : _a.device_id) === deviceId; });
-    }
-    transportType() {
-        return this.transport.name;
-    }
-    getTransportInfo() {
-        return {
-            type: this.transportType(),
-            version: this.transport.version,
-            outdated: this.transport.isOutdated,
-        };
+        return this.devices.all().find(d => { var _a; return ((_a = d.features) === null || _a === void 0 ? void 0 : _a.device_id) === deviceId; });
     }
-    dispose() {
+    async dispose() {
         this.removeAllListeners();
-        return this.cleanup();
+        const promises = (0, utils_2.typedObjectKeys)(this.transport)
+            .concat((0, utils_2.typedObjectKeys)(this.locks))
+            .filter(utils_1.arrayDistinct)
+            .map(apiType => this.transportLock(apiType, 'Disposing', async () => {
+            const transport = this.transport[apiType];
+            if (transport) {
+                delete this.transport[apiType];
+                await this.stopTransport(transport);
+            }
+        }));
+        await Promise.all(promises);
     }
-    async cleanup() {
-        var _a;
-        const { transport } = this;
-        const devices = this.getAllDevices();
-        this.transport = undefined;
-        this.authPenaltyManager.clear();
-        (0, utils_2.typedObjectKeys)(this.devices).forEach(key => delete this.devices[key]);
-        (_a = this.rejectPending) === null || _a === void 0 ? void 0 : _a.call(this, new Error('Disposed'));
+    async stopTransport(transport) {
+        const devices = this.devices.clear(transport);
         devices.forEach(device => {
-            this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
+            this.emit(events_1.DEVICE.DISCONNECT, device);
         });
-        await Promise.all(devices.map(device => device.dispose()));
+        await Promise.all(devices.map(async (device) => {
+            this.authPenaltyManager.remove(device);
+            await device.dispose();
+        }));
         transport === null || transport === void 0 ? void 0 : transport.stop();
     }
-    async enumerate(transport = this.transport) {
-        const res = await transport.enumerate();
-        if (!res.success) {
-            return;
-        }
-        res.payload.forEach(d => {
-            var _a;
-            (_a = this.devices[d.path]) === null || _a === void 0 ? void 0 : _a.updateDescriptor(d);
+    async enumerate() {
+        const promises = Object.values(this.transport).map(async (transport) => {
+            const res = await transport.enumerate();
+            if (!res.success) {
+                return;
+            }
+            res.payload.forEach(d => {
+                var _a;
+                (_a = this.devices.get(d.path, transport)) === null || _a === void 0 ? void 0 : _a.updateDescriptor(d);
+            });
         });
+        await Promise.all(promises);
     }
     addAuthPenalty(device) {
         return this.authPenaltyManager.add(device);

package/lib/device/StateStorage.js

@@ -21,19 +21,17 @@ class WebextensionStateStorage {
     saveState(device, state) {
         var _a;
         const expirationDelay = Math.max(1000 * 60 * 15, (_a = device.features.auto_lock_delay_ms) !== null && _a !== void 0 ? _a : 0);
-        connect_common_1.storage.saveForOrigin(store => {
-            return {
-                ...store,
-                preferredDevice: store.preferredDevice
-                    ? {
-                        ...store.preferredDevice,
-                        state: state.staticSessionId,
-                        internalState: state.sessionId,
-                        internalStateExpiration: Date.now() + expirationDelay,
-                    }
-                    : undefined,
-            };
-        }, this.origin);
+        connect_common_1.storage.saveForOrigin(store => ({
+            ...store,
+            preferredDevice: store.preferredDevice
+                ? {
+                    ...store.preferredDevice,
+                    state: state.staticSessionId,
+                    internalState: state.sessionId,
+                    internalStateExpiration: Date.now() + expirationDelay,
+                }
+                : undefined,
+        }), this.origin);
     }
 }
 exports.WebextensionStateStorage = WebextensionStateStorage;

package/lib/device/prompts.js

@@ -21,44 +21,36 @@ const cancelPrompt = (device, expectResponse = true) => {
     return expectResponse ? device.transport.call(cancelArgs) : device.transport.send(cancelArgs);
 };
 exports.cancelPrompt = cancelPrompt;
-const prompt = (event, ...[device, ...args]) => {
-    return new Promise((resolve, reject) => {
-        const cancelAndReject = (error) => (0, exports.cancelPrompt)(device).then(onCancel => {
-            var _a;
-            return reject(error ||
-                new Error(onCancel.success
-                    ? (_a = onCancel.payload) === null || _a === void 0 ? void 0 : _a.message.message
-                    : onCancel.error));
-        });
-        if (device.listenerCount(event) > 0) {
-            device.setCancelableAction(cancelAndReject);
-            const callback = (...[response, error]) => {
-                device.clearCancelableAction();
-                if (error || response == null) {
-                    cancelAndReject(error);
-                }
-                else {
-                    resolve(response);
-                }
-            };
-            const emitArgs = [event, device, ...args, callback];
-            device.emit(...emitArgs);
-        }
-        else {
-            cancelAndReject(constants_1.ERRORS.TypedError('Runtime', `${event} callback not configured`));
-        }
+const prompt = (event, ...[device, ...args]) => new Promise((resolve, reject) => {
+    const cancelAndReject = (error) => (0, exports.cancelPrompt)(device).then(onCancel => {
+        var _a;
+        return reject(error ||
+            new Error(onCancel.success
+                ? (_a = onCancel.payload) === null || _a === void 0 ? void 0 : _a.message.message
+                : onCancel.error));
     });
-};
-const promptPassphrase = (device) => {
-    return prompt(events_1.DEVICE.PASSPHRASE, device);
-};
+    if (device.listenerCount(event) > 0) {
+        device.setCancelableAction(cancelAndReject);
+        const callback = (...[response, error]) => {
+            device.clearCancelableAction();
+            if (error || response == null) {
+                cancelAndReject(error);
+            }
+            else {
+                resolve(response);
+            }
+        };
+        const emitArgs = [event, device, ...args, callback];
+        device.emit(...emitArgs);
+    }
+    else {
+        cancelAndReject(constants_1.ERRORS.TypedError('Runtime', `${event} callback not configured`));
+    }
+});
+const promptPassphrase = (device) => prompt(events_1.DEVICE.PASSPHRASE, device);
 exports.promptPassphrase = promptPassphrase;
-const promptPin = (device, type) => {
-    return prompt(events_1.DEVICE.PIN, device, type);
-};
+const promptPin = (device, type) => prompt(events_1.DEVICE.PIN, device, type);
 exports.promptPin = promptPin;
-const promptWord = (device, type) => {
-    return prompt(events_1.DEVICE.WORD, device, type);
-};
+const promptWord = (device, type) => prompt(events_1.DEVICE.WORD, device, type);
 exports.promptWord = promptWord;
 //# sourceMappingURL=prompts.js.map

package/lib/device/resolveDescriptorForTaproot.d.ts

@@ -1,10 +1,10 @@
 import { MessagesSchema as Messages } from '@trezor/protobuf';
 import { HDNodeResponse } from '../types/api/getPublicKey';
-interface Params {
+interface ResolveDescriptorForTaprootParams {
     response: HDNodeResponse;
     publicKey: Messages.PublicKey;
 }
-export declare const resolveDescriptorForTaproot: ({ response, publicKey }: Params) => {
+export declare const resolveDescriptorForTaproot: ({ response, publicKey, }: ResolveDescriptorForTaprootParams) => {
     xpub: string;
     checksum: string;
 } | {

package/lib/device/resolveDescriptorForTaproot.js

@@ -1,21 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveDescriptorForTaproot = void 0;
-const resolveDescriptorForTaproot = ({ response, publicKey }) => {
+const utils_1 = require("@trezor/utils");
+const resolveDescriptorForTaproot = ({ response, publicKey, }) => {
     if (publicKey.descriptor !== null && publicKey.descriptor !== undefined) {
         const [xpub, checksum] = publicKey.descriptor.split('#');
-        const openingSquareBracketSplit = xpub.split('[');
-        if (openingSquareBracketSplit.length === 2) {
-            const [beforeOpeningBracket, afterOpeningBracket] = openingSquareBracketSplit;
-            const closingSquareBracketSplit = afterOpeningBracket.split(']');
-            if (closingSquareBracketSplit.length === 2) {
-                const [path, afterClosingBracket] = closingSquareBracketSplit;
-                const correctedPath = path.replace(/h/g, "'");
-                return {
-                    xpub: `${beforeOpeningBracket}[${correctedPath}]${afterClosingBracket}`,
-                    checksum,
-                };
-            }
+        const correctedXpub = (0, utils_1.convertTaprootXpub)({ xpub, direction: 'h-to-apostrophe' });
+        if (correctedXpub !== null) {
+            return { xpub: correctedXpub, checksum };
         }
     }
     const fingerprint = Number(publicKey.root_fingerprint || 0)

package/lib/events/blockchain.d.ts

@@ -1,4 +1,4 @@
-import type { ServerInfo, BlockEvent, FiatRatesBySymbol, NotificationEvent } from '@trezor/blockchain-link';
+import type { BlockEvent, FiatRatesBySymbol, NotificationEvent, ServerInfo } from '@trezor/blockchain-link';
 import type { CoinInfo } from '../types/coinInfo';
 import type { MessageFactoryFn } from '../types/utils';
 export declare const BLOCKCHAIN_EVENT = "BLOCKCHAIN_EVENT";

package/lib/events/call.d.ts

@@ -1,7 +1,7 @@
 import type { IFRAME } from './iframe';
+import { Device } from '../device/Device';
 import type { TrezorConnect } from '../types/api';
 import type { CommonParams, DeviceIdentity } from '../types/params';
-import { Device } from '../device/Device';
 type UnwrappedResponse<Response> = Response extends Promise<infer R> ? R extends {
     success: true;
     payload: infer P;