@trezor/connect 9.4.3-beta.1 → 9.4.3-beta.2

package/lib/device/DeviceList.d.ts

@@ -2,7 +2,7 @@ import { TypedEmitter } from '@trezor/utils';
 import { Transport, TRANSPORT } from '@trezor/transport';
 import { DEVICE, TransportInfo } from '../events';
 import { Device } from './Device';
-import type { ConnectSettings, Device as DeviceTyped } from '../types';
+import { ConnectSettings, DeviceUniquePath, Device as DeviceTyped } from '../types';
 interface DeviceListEvents {
     [TRANSPORT.START]: TransportInfo;
     [TRANSPORT.ERROR]: string;
@@ -10,8 +10,6 @@ interface DeviceListEvents {
     [DEVICE.CONNECT_UNACQUIRED]: DeviceTyped;
     [DEVICE.DISCONNECT]: DeviceTyped;
     [DEVICE.CHANGED]: DeviceTyped;
-    [DEVICE.RELEASED]: DeviceTyped;
-    [DEVICE.ACQUIRED]: DeviceTyped;
 }
 export interface IDeviceList {
     isConnected(): this is DeviceList;
@@ -25,7 +23,7 @@ export interface IDeviceList {
     dispose: DeviceList['dispose'];
 }
 export declare const assertDeviceListConnected: (deviceList: IDeviceList) => asserts deviceList is DeviceList;
-type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | '_sessionsBackgroundUrl'> & {
+type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | '_sessionsBackgroundUrl' | 'manifest'> & {
     messages: Record<string, any>;
 };
 type InitParams = Pick<ConnectSettings, 'pendingTransportEvent' | 'transportReconnect'>;
@@ -33,34 +31,31 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
     private transport;
     private transports;
     private devices;
-    private creatingDevicesDescriptors;
-    private createDevicesQueue;
+    private deviceCounter;
+    private readonly handshakeLock;
     private readonly authPenaltyManager;
     private initPromise?;
     private rejectPending?;
     private transportCommonArgs;
     isConnected(): this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
-    constructor({ messages, priority, debug, _sessionsBackgroundUrl }: ConstructorParams);
+    constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }: ConstructorParams);
     private createTransport;
     setTransports(transports: ConnectSettings['transports']): void;
-    private onTransportUpdate;
-    private waitForCreateDevicesQueue;
-    private removeFromCreateDevicesQueue;
+    private onDeviceConnected;
+    private onDeviceDisconnected;
+    private onDeviceSessionChanged;
+    private onDeviceRequestRelease;
     init(initParams?: InitParams): Promise<void>;
     private createInitPromise;
     private createReconnectPromise;
     private selectTransport;
     private initializeTransport;
     private waitForDevices;
-    private _createAndSaveDevice;
-    private _createUnacquiredDevice;
-    private _createUnreadableDevice;
-    getDevice(path: string): Device;
-    getFirstDevicePath(): string;
-    asArray(): DeviceTyped[];
-    allDevices(): Device[];
-    length(): number;
+    getDeviceCount(): number;
+    getAllDevices(): Device[];
+    getOnlyDevice(): Device | undefined;
+    getDeviceByPath(path: DeviceUniquePath): Device | undefined;
     transportType(): "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport";
     getTransportInfo(): TransportInfo;
     dispose(): Promise<void>;
@@ -68,9 +63,6 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
     enumerate(transport?: Transport): Promise<void>;
     addAuthPenalty(device: Device): void;
     removeAuthPenalty(device: Device): void;
-    private handle;
-    private _takeAndCreateDevice;
-    private _handleUsedElsewhere;
 }
 export {};
 //# sourceMappingURL=DeviceList.d.ts.map

package/lib/device/DeviceList.js

@@ -6,9 +6,11 @@ const transport_1 = require("@trezor/transport");
 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 utils_2 = require("../types/utils");
 const _log = (0, debug_1.initLog)('DeviceList');
 const createAuthPenaltyManager = (priority) => {
     const penalizedDevices = {};
@@ -42,17 +44,18 @@ class DeviceList extends utils_1.TypedEmitter {
     pendingConnection() {
         return this.initPromise;
     }
-    constructor({ messages, priority, debug, _sessionsBackgroundUrl }) {
+    constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }) {
         super();
         this.devices = {};
-        this.creatingDevicesDescriptors = {};
-        this.createDevicesQueue = [];
+        this.deviceCounter = Date.now();
         const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
+        this.handshakeLock = (0, utils_1.getSynchronize)();
         this.authPenaltyManager = createAuthPenaltyManager(priority);
         this.transportCommonArgs = {
             messages,
             logger: transportLogger,
             sessionsBackgroundUrl: _sessionsBackgroundUrl,
+            id: (manifest === null || manifest === void 0 ? void 0 : manifest.appUrl) || 'unknown app',
         };
         this.transports = [
             new transport_1.BridgeTransport({
@@ -96,91 +99,41 @@ class DeviceList extends utils_1.TypedEmitter {
         const transportTypes = (transports === null || transports === void 0 ? void 0 : transports.length) ? transports : ['BridgeTransport'];
         this.transports = transportTypes.map(this.createTransport.bind(this));
     }
-    onTransportUpdate(diff, transport) {
-        diff.forEach(async ({ descriptor, ...category }) => {
-            var _a;
-            const path = descriptor.path.toString();
-            const device = this.devices[path];
-            this.creatingDevicesDescriptors[path] = descriptor;
-            switch (category.type) {
-                case 'disconnected':
-                    this.removeFromCreateDevicesQueue(path);
-                    if (!device)
-                        break;
-                    device.disconnect();
-                    delete this.devices[path];
-                    this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
-                    break;
-                case 'connected':
-                    if (!(await this.waitForCreateDevicesQueue(path))) {
-                        break;
-                    }
-                    const penalty = this.authPenaltyManager.get();
-                    if (penalty) {
-                        await (0, promiseUtils_1.resolveAfter)(501 + penalty, null).promise;
-                    }
-                    if (this.creatingDevicesDescriptors[path].session == null) {
-                        await this._createAndSaveDevice(descriptor, transport);
-                    }
-                    else {
-                        const device = this._createUnacquiredDevice(descriptor, transport);
-                        this.devices[path] = device;
-                        this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
-                    }
-                    this.removeFromCreateDevicesQueue(path);
-                    break;
-                case 'acquired':
-                    if (category.subtype === 'elsewhere') {
-                        this.removeFromCreateDevicesQueue(path);
-                        if (device) {
-                            device.featuresNeedsReload = true;
-                            device.interruptionFromOutside();
-                        }
-                    }
-                    if (!device)
-                        break;
-                    _log.debug('Event', events_1.DEVICE.CHANGED, device.toMessageObject());
-                    this.emit(events_1.DEVICE.CHANGED, device.toMessageObject());
-                    _log.debug('Event', events_1.DEVICE.ACQUIRED, device.toMessageObject());
-                    this.emit(events_1.DEVICE.ACQUIRED, device.toMessageObject());
-                    break;
-                case 'released':
-                    if (!device)
-                        break;
-                    const methodStillRunning = !((_a = device.commands) === null || _a === void 0 ? void 0 : _a.isDisposed());
-                    if (methodStillRunning) {
-                        device.keepTransportSession = false;
-                    }
-                    _log.debug('Event', events_1.DEVICE.CHANGED, device.toMessageObject());
-                    this.emit(events_1.DEVICE.CHANGED, device.toMessageObject());
-                    _log.debug('Event', events_1.DEVICE.RELEASED, device.toMessageObject());
-                    this.emit(events_1.DEVICE.RELEASED, device.toMessageObject());
-                    if (category.subtype === 'elsewhere') {
-                        await (0, promiseUtils_1.resolveAfter)(1000, null).promise;
-                        if (!device.isUsed() && device.isUnacquired() && !device.isInconsistent()) {
-                            _log.debug('Create device from unacquired', device.toMessageObject());
-                            await this._createAndSaveDevice(descriptor, transport);
-                        }
-                    }
-                    break;
+    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()),
+        });
+        this.devices[path] = device;
+        const penalty = this.authPenaltyManager.get();
+        this.handshakeLock(async () => {
+            if (this.devices[path]) {
+                await device.handshake(penalty);
             }
-            device === null || device === void 0 ? void 0 : device.updateDescriptor(descriptor);
         });
     }
-    async waitForCreateDevicesQueue(path) {
-        const dfd = (0, utils_1.createDeferred)(path);
-        const prevQueue = this.createDevicesQueue.slice();
-        this.createDevicesQueue.push(dfd);
-        await (0, utils_1.promiseAllSequence)(prevQueue.map(pr => () => pr.promise));
-        return this.createDevicesQueue.includes(dfd);
+    onDeviceDisconnected(descriptor) {
+        const { path } = descriptor;
+        const device = this.devices[path];
+        if (device) {
+            device.disconnect();
+            delete this.devices[path];
+        }
     }
-    removeFromCreateDevicesQueue(path) {
-        const index = this.createDevicesQueue.findIndex(dfd => dfd.id === path);
-        if (index >= 0) {
-            const [dfd] = this.createDevicesQueue.splice(index, 1);
-            dfd.resolve();
+    onDeviceSessionChanged(descriptor) {
+        const device = this.devices[descriptor.path];
+        if (device) {
+            device.updateDescriptor(descriptor);
         }
     }
+    onDeviceRequestRelease(descriptor) {
+        var _a;
+        (_a = this.devices[descriptor.path]) === null || _a === void 0 ? void 0 : _a.usedElsewhere();
+    }
     init(initParams = {}) {
         if (!this.initPromise) {
             _log.debug('Initializing transports');
@@ -207,7 +160,9 @@ class DeviceList extends utils_1.TypedEmitter {
     createReconnectPromise(initParams) {
         const { promise, reject } = (0, promiseUtils_1.resolveAfter)(1000, initParams);
         this.rejectPending = reject;
-        return promise.then(this.createInitPromise.bind(this));
+        return promise.then(this.createInitPromise.bind(this)).finally(() => {
+            this.rejectPending = undefined;
+        });
     }
     async selectTransport([transport, ...rest]) {
         const result = await transport.init();
@@ -219,7 +174,10 @@ class DeviceList extends utils_1.TypedEmitter {
             throw new Error(result.error);
     }
     async initializeTransport(transport, initParams) {
-        transport.on(transport_1.TRANSPORT.UPDATE, diff => this.onTransportUpdate(diff, transport));
+        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);
@@ -260,36 +218,17 @@ class DeviceList extends utils_1.TypedEmitter {
             this.off(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceConnect);
         });
     }
-    async _createAndSaveDevice(descriptor, transport) {
-        _log.debug('Creating Device', descriptor);
-        await this.handle(descriptor, transport);
-    }
-    _createUnacquiredDevice(descriptor, transport) {
-        _log.debug('Creating Unacquired Device', descriptor);
-        const device = Device_1.Device.createUnacquired(transport, descriptor);
-        device.once(events_1.DEVICE.ACQUIRED, () => {
-            this.emit(events_1.DEVICE.CONNECT, device.toMessageObject());
-        });
-        return device;
-    }
-    _createUnreadableDevice(descriptor, transport, unreadableError) {
-        _log.debug('Creating Unreadable Device', descriptor, unreadableError);
-        return Device_1.Device.createUnacquired(transport, descriptor, unreadableError);
+    getDeviceCount() {
+        return Object.keys(this.devices).length;
     }
-    getDevice(path) {
-        return this.devices[path];
+    getAllDevices() {
+        return (0, utils_2.typedObjectKeys)(this.devices).map(key => this.devices[key]);
     }
-    getFirstDevicePath() {
-        return this.asArray()[0].path;
+    getOnlyDevice() {
+        return this.getDeviceCount() === 1 ? Object.values(this.devices)[0] : undefined;
     }
-    asArray() {
-        return this.allDevices().map(device => device.toMessageObject());
-    }
-    allDevices() {
-        return Object.keys(this.devices).map(key => this.devices[key]);
-    }
-    length() {
-        return this.asArray().length;
+    getDeviceByPath(path) {
+        return this.getAllDevices().find(d => d.getUniquePath() === path);
     }
     transportType() {
         return this.transport.name;
@@ -308,16 +247,14 @@ class DeviceList extends utils_1.TypedEmitter {
     async cleanup() {
         var _a;
         const { transport } = this;
-        const devices = this.allDevices();
+        const devices = this.getAllDevices();
         this.transport = undefined;
         this.authPenaltyManager.clear();
-        Object.keys(this.devices).forEach(key => delete this.devices[key]);
+        (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'));
         devices.forEach(device => {
             this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
         });
-        this.createDevicesQueue.forEach(dfd => dfd.resolve());
-        this.createDevicesQueue = [];
         await Promise.all(devices.map(device => device.dispose()));
         transport === null || transport === void 0 ? void 0 : transport.stop();
     }
@@ -327,9 +264,8 @@ class DeviceList extends utils_1.TypedEmitter {
             return;
         }
         res.payload.forEach(d => {
-            if (this.devices[d.path]) {
-                this.devices[d.path].updateDescriptor(d);
-            }
+            var _a;
+            (_a = this.devices[d.path]) === null || _a === void 0 ? void 0 : _a.updateDescriptor(d);
         });
     }
     addAuthPenalty(device) {
@@ -338,56 +274,6 @@ class DeviceList extends utils_1.TypedEmitter {
     removeAuthPenalty(device) {
         return this.authPenaltyManager.remove(device);
     }
-    async handle(descriptor, transport) {
-        var _a;
-        const path = descriptor.path.toString();
-        try {
-            await this._takeAndCreateDevice(descriptor, transport);
-        }
-        catch (error) {
-            _log.debug('Cannot create device', error);
-            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.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) {
-                this.enumerate(transport);
-                this._handleUsedElsewhere(descriptor, transport);
-            }
-            else if (error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE ||
-                ((_a = error.message) === null || _a === void 0 ? void 0 : _a.indexOf(constants_1.ERRORS.LIBUSB_ERROR_MESSAGE)) >= 0 ||
-                error.code === 'Device_InitializeFailed') {
-                const device = this._createUnreadableDevice(this.creatingDevicesDescriptors[path], transport, error.message);
-                this.devices[path] = device;
-                this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
-            }
-            else if (error.code === 'Device_UsedElsewhere') {
-                this._handleUsedElsewhere(descriptor, transport);
-            }
-            else {
-                await (0, promiseUtils_1.resolveAfter)(501, null).promise;
-                await this.handle(descriptor, transport);
-            }
-        }
-    }
-    async _takeAndCreateDevice(descriptor, transport) {
-        const device = Device_1.Device.fromDescriptor(transport, descriptor);
-        const path = descriptor.path.toString();
-        this.devices[path] = device;
-        const promise = device.run();
-        await promise;
-        this.emit(events_1.DEVICE.CONNECT, device.toMessageObject());
-    }
-    _handleUsedElsewhere(descriptor, transport) {
-        const path = descriptor.path.toString();
-        const device = this._createUnacquiredDevice(this.creatingDevicesDescriptors[path], transport);
-        this.devices[path] = device;
-        this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
-    }
 }
 exports.DeviceList = DeviceList;
 //# sourceMappingURL=DeviceList.js.map

package/lib/device/prompts.js

@@ -5,14 +5,15 @@ const transport_1 = require("@trezor/transport");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const cancelPrompt = (device, expectResponse = true) => {
-    if (!device.transportSession) {
+    const session = device.getLocalSession();
+    if (!session) {
         return Promise.resolve({
             success: false,
             error: transport_1.TRANSPORT_ERROR.SESSION_NOT_FOUND,
         });
     }
     const cancelArgs = {
-        session: device.transportSession,
+        session,
         name: 'Cancel',
         data: {},
         protocol: device.protocol,

package/lib/device/resolveDescriptorForTaproot.d.ts

@@ -1,5 +1,5 @@
-import { HDNodeResponse } from '../types/api/getPublicKey';
 import { MessagesSchema as Messages } from '@trezor/protobuf';
+import { HDNodeResponse } from '../types/api/getPublicKey';
 interface Params {
     response: HDNodeResponse;
     publicKey: Messages.PublicKey;

package/lib/events/call.d.ts

@@ -2,15 +2,15 @@ import type { IFRAME } from './iframe';
 import type { TrezorConnect } from '../types/api';
 import type { CommonParams, DeviceIdentity } from '../types/params';
 import { Device } from '../device/Device';
-type UnwrappedResponse<T> = T extends Promise<infer R> ? (R extends {
+type UnwrappedResponse<Response> = Response extends Promise<infer R> ? R extends {
     success: true;
     payload: infer P;
-} ? P : never) : void;
-type OverloadedMethod<T, E extends Record<string, string>> = T extends {
+} ? P : never : void;
+type OverloadedMethod<Method, Params extends Record<string, string>> = Method extends {
     (params: infer P1): infer R1;
     (params: infer P2): infer R2;
-} ? ((params: P1 & E) => R1) | ((params: P2 & E) => R2) : T extends (...args: infer P) => infer R ? (params: E & P[0]) => R : never;
-type UnwrappedMethod<T, M extends Record<string, string>> = T extends () => infer R ? (params: M & CommonParams) => R : OverloadedMethod<T, M>;
+} ? ((params: P1 & Params) => R1) | ((params: P2 & Params) => R2) : Method extends (...args: infer P) => infer R ? (params: Params & P[0]) => R : never;
+type UnwrappedMethod<Method, Params extends Record<string, string>> = Method extends () => infer R ? (params: Params & CommonParams) => R : OverloadedMethod<Method, Params>;
 type IsMethodCallable<T> = T extends (...args: any[]) => infer R ? R extends Promise<{
     success: boolean;
 }> ? R : never : never;

package/lib/events/call.js

@@ -11,9 +11,9 @@ const createResponseMessage = (id, success, payload, device) => ({
     payload: success ? payload : (0, errors_1.serializeError)(payload),
     device: device
         ? {
-            path: device === null || device === void 0 ? void 0 : device.originalDescriptor.path,
+            path: device === null || device === void 0 ? void 0 : device.getUniquePath(),
             state: device === null || device === void 0 ? void 0 : device.getState(),
-            instance: device === null || device === void 0 ? void 0 : device.instance,
+            instance: device === null || device === void 0 ? void 0 : device.getInstance(),
         }
         : undefined,
 });

package/lib/events/device.d.ts

@@ -7,12 +7,6 @@ export declare const DEVICE: {
     readonly CONNECT_UNACQUIRED: "device-connect_unacquired";
     readonly DISCONNECT: "device-disconnect";
     readonly CHANGED: "device-changed";
-    readonly ACQUIRE: "device-acquire";
-    readonly RELEASE: "device-release";
-    readonly ACQUIRED: "device-acquired";
-    readonly RELEASED: "device-released";
-    readonly USED_ELSEWHERE: "device-used_elsewhere";
-    readonly LOADING: "device-loading";
     readonly BUTTON: "button";
     readonly PIN: "pin";
     readonly PASSPHRASE: "passphrase";

package/lib/events/device.js

@@ -7,12 +7,6 @@ exports.DEVICE = {
     CONNECT_UNACQUIRED: 'device-connect_unacquired',
     DISCONNECT: 'device-disconnect',
     CHANGED: 'device-changed',
-    ACQUIRE: 'device-acquire',
-    RELEASE: 'device-release',
-    ACQUIRED: 'device-acquired',
-    RELEASED: 'device-released',
-    USED_ELSEWHERE: 'device-used_elsewhere',
-    LOADING: 'device-loading',
     BUTTON: 'button',
     PIN: 'pin',
     PASSPHRASE: 'passphrase',

package/lib/events/transport.d.ts

@@ -1,6 +1,6 @@
-import type { MessageFactoryFn } from '../types/utils';
 import type { Transport } from '@trezor/transport';
 import { TRANSPORT } from '@trezor/transport/lib/constants';
+import type { MessageFactoryFn } from '../types/utils';
 export { TRANSPORT } from '@trezor/transport/lib/constants';
 export declare const TRANSPORT_EVENT = "TRANSPORT_EVENT";
 export interface BridgeInfo {

package/lib/factory.d.ts

@@ -1,18 +1,18 @@
 import type { EventEmitter } from 'events';
 import type { TrezorConnect } from './types';
 import type { CallMethod } from './events/call';
-export interface ConnectFactoryDependencies {
+import type { InitType } from './types/api/init';
+export interface ConnectFactoryDependencies<SettingsType extends Record<string, any>> {
+    init: InitType<SettingsType>;
     call: CallMethod;
     eventEmitter: EventEmitter;
     manifest: TrezorConnect['manifest'];
-    init: TrezorConnect['init'];
     requestLogin: TrezorConnect['requestLogin'];
     uiResponse: TrezorConnect['uiResponse'];
-    renderWebUSBButton: TrezorConnect['renderWebUSBButton'];
-    disableWebUSB: TrezorConnect['disableWebUSB'];
-    requestWebUSBDevice: TrezorConnect['requestWebUSBDevice'];
     cancel: TrezorConnect['cancel'];
     dispose: TrezorConnect['dispose'];
 }
-export declare const factory: ({ eventEmitter, manifest, init, call, requestLogin, uiResponse, renderWebUSBButton, disableWebUSB, requestWebUSBDevice, cancel, dispose, }: ConnectFactoryDependencies) => TrezorConnect;
+export declare const factory: <SettingsType extends Record<string, any>, ExtraMethodsType extends Record<string, any>>({ eventEmitter, manifest, init, call, requestLogin, uiResponse, cancel, dispose, }: ConnectFactoryDependencies<SettingsType>, extraMethods?: ExtraMethodsType) => Omit<TrezorConnect, "init"> & {
+    init: InitType<SettingsType>;
+} & ExtraMethodsType;
 //# sourceMappingURL=factory.d.ts.map