@trezor/connect 9.2.2 → 9.2.4-beta.1

package/lib/api/tezos/api/tezosGetAddress.js

@@ -15,6 +15,7 @@ class TezosGetAddress extends AbstractMethod_1.AbstractMethod {
         this.progress = 0;
     }
     init() {
+        this.noBackupConfirmationMode = 'always';
         this.requiredPermissions = ['read'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Tezos'), this.firmwareRange);
         this.hasBundle = !!this.payload.bundle;
@@ -35,7 +36,6 @@ class TezosGetAddress extends AbstractMethod_1.AbstractMethod {
             this.params.length === 1 &&
             typeof this.params[0].address === 'string' &&
             this.params[0].show_display;
-        this.confirmed = useEventListener;
         this.useUi = !useEventListener;
     }
     get info() {
@@ -53,27 +53,11 @@ class TezosGetAddress extends AbstractMethod_1.AbstractMethod {
             };
         }
     }
-    async confirmation() {
-        if (this.confirmed)
-            return true;
-        await this.getPopupPromise().promise;
-        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+    get confirmation() {
+        return {
             view: 'export-address',
             label: this.info,
-        }));
-        const uiResp = await uiPromise.promise;
-        this.confirmed = uiResp.payload;
-        return this.confirmed;
-    }
-    async noBackupConfirmation() {
-        await this.getPopupPromise().promise;
-        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
-            view: 'no-backup',
-        }));
-        const uiResp = await uiPromise.promise;
-        return uiResp.payload;
+        };
     }
     async _call({ address_n, show_display, chunkify }) {
         const cmd = this.device.getCommands();

package/lib/api/tezos/api/tezosGetPublicKey.d.ts

@@ -2,10 +2,12 @@ import { AbstractMethod } from '../../../core/AbstractMethod';
 import type { PROTO } from '../../../constants';
 export default class TezosGetPublicKey extends AbstractMethod<'tezosGetPublicKey', PROTO.TezosGetPublicKey[]> {
     hasBundle?: boolean;
-    confirmed?: boolean;
     init(): void;
     get info(): string;
-    confirmation(): Promise<boolean>;
+    get confirmation(): {
+        view: "export-address";
+        label: string;
+    };
     run(): Promise<{
         path: number[];
         publicKey: string;

package/lib/api/tezos/api/tezosGetPublicKey.js

@@ -28,25 +28,13 @@ class TezosGetPublicKey extends AbstractMethod_1.AbstractMethod {
     get info() {
         return 'Export Tezos public key';
     }
-    async confirmation() {
-        if (this.confirmed)
-            return true;
-        await this.getPopupPromise().promise;
-        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
-        let label;
-        if (this.params.length > 1) {
-            label = 'Export multiple Tezos public keys';
-        }
-        else {
-            label = `Export Tezos public key for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
-        }
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+    get confirmation() {
+        return {
             view: 'export-address',
-            label,
-        }));
-        const uiResp = await uiPromise.promise;
-        this.confirmed = uiResp.payload;
-        return this.confirmed;
+            label: this.params.length > 1
+                ? 'Export multiple Tezos public keys'
+                : `Export Tezos public key for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`,
+        };
     }
     async run() {
         const responses = [];

package/lib/api/wipeDevice.d.ts

@@ -1,8 +1,14 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 export default class WipeDevice extends AbstractMethod<'wipeDevice'> {
-    confirmed?: boolean;
     init(): void;
-    confirmation(): Promise<boolean>;
+    get confirmation(): {
+        view: "device-management";
+        customConfirmButton: {
+            className: string;
+            label: string;
+        };
+        label: string;
+    };
     get info(): string;
     run(): Promise<{
         message: string;

package/lib/api/wipeDevice.js

@@ -10,22 +10,15 @@ class WipeDevice extends AbstractMethod_1.AbstractMethod {
         this.requiredPermissions = ['management'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
     }
-    async confirmation() {
-        if (this.confirmed)
-            return true;
-        await this.getPopupPromise().promise;
-        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+    get confirmation() {
+        return {
             view: 'device-management',
             customConfirmButton: {
                 className: 'wipe',
                 label: `Wipe ${this.device.toMessageObject().label}`,
             },
             label: 'Are you sure you want to wipe your device?',
-        }));
-        const uiResp = await uiPromise.promise;
-        this.confirmed = uiResp.payload;
-        return this.confirmed;
+        };
     }
     get info() {
         return 'Wipe device';

package/lib/backend/BackendManager.d.ts

@@ -1,15 +1,16 @@
 import { Blockchain, BlockchainOptions } from './Blockchain';
 import type { CoinInfo, BlockchainLink } from '../types';
 type CoinShortcut = CoinInfo['shortcut'];
+type BackendParams = Pick<BlockchainOptions, 'coinInfo' | 'postMessage' | 'identity'>;
 export declare class BackendManager {
     private readonly instances;
+    private readonly reconnect;
     private readonly custom;
     private readonly preferred;
-    private readonly reconnect;
-    get(shortcut: CoinShortcut): Blockchain | null;
-    getOrConnect(coinInfo: CoinInfo, postMessage: BlockchainOptions['postMessage']): Promise<Blockchain>;
+    get(shortcut: CoinShortcut, identity?: string): Blockchain | null;
+    getOrConnect({ coinInfo, postMessage, identity }: BackendParams): Promise<Blockchain>;
     dispose(): void;
-    reconnectAll(): Promise<Blockchain[]>;
+    reconnectAll(coin?: CoinInfo): Promise<Blockchain[]>;
     isSupported(coinInfo: CoinInfo): void;
     setCustom(shortcut: CoinShortcut, blockchainLink: BlockchainLink): void;
     removeCustom(shortcut: CoinShortcut): void;
@@ -18,6 +19,7 @@ export declare class BackendManager {
     private onDisconnect;
     private clearReconnect;
     private patchCoinInfo;
+    private getReconnectFilter;
 }
 export {};
 //# sourceMappingURL=BackendManager.d.ts.map

package/lib/backend/BackendManager.js

@@ -5,52 +5,56 @@ const DataManager_1 = require("../data/DataManager");
 const constants_1 = require("../constants");
 const Blockchain_1 = require("./Blockchain");
 const events_1 = require("../events");
+const DEFAULT_IDENTITY = 'default';
 class BackendManager {
     constructor() {
         this.instances = {};
+        this.reconnect = {};
         this.custom = {};
         this.preferred = {};
-        this.reconnect = {};
     }
-    get(shortcut) {
+    get(shortcut, identity = DEFAULT_IDENTITY) {
         var _a;
-        return (_a = this.instances[shortcut]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.instances[`${shortcut}/${identity}`]) !== null && _a !== void 0 ? _a : null;
     }
-    async getOrConnect(coinInfo, postMessage) {
-        let backend = this.instances[coinInfo.shortcut];
+    async getOrConnect({ coinInfo, postMessage, identity }) {
+        const coinIdentity = `${coinInfo.shortcut}/${identity !== null && identity !== void 0 ? identity : DEFAULT_IDENTITY}`;
+        let backend = this.instances[coinIdentity];
         if (!backend) {
             backend = new Blockchain_1.Blockchain({
                 coinInfo: this.patchCoinInfo(coinInfo),
-                postMessage,
+                identity,
                 debug: DataManager_1.DataManager.getSettings('debug'),
                 proxy: DataManager_1.DataManager.getSettings('proxy'),
+                postMessage,
                 onDisconnected: pendingSubscriptions => {
                     const reconnectAttempts = pendingSubscriptions ? 0 : undefined;
-                    this.onDisconnect(coinInfo, postMessage, reconnectAttempts);
+                    this.onDisconnect({ coinInfo, postMessage, identity }, reconnectAttempts);
                 },
             });
-            this.setInstance(coinInfo.shortcut, backend);
+            this.setInstance(coinIdentity, backend);
         }
-        const reconnect = this.clearReconnect(coinInfo.shortcut);
+        const reconnect = this.clearReconnect(coinIdentity);
         try {
             const info = await backend.init();
             this.setPreferred(coinInfo.shortcut, info.url);
             return backend;
         }
         catch (error) {
-            this.onDisconnect(coinInfo, postMessage, reconnect === null || reconnect === void 0 ? void 0 : reconnect.attempts);
+            this.onDisconnect({ coinInfo, postMessage, identity }, reconnect === null || reconnect === void 0 ? void 0 : reconnect.attempts);
             throw error;
         }
     }
     dispose() {
-        Object.keys(this.reconnect).forEach(this.clearReconnect, this);
+        Object.keys(this.reconnect)
+            .filter(this.getReconnectFilter())
+            .forEach(this.clearReconnect, this);
         Object.values(this.instances).forEach(i => i.disconnect());
     }
-    reconnectAll() {
-        Object.keys(this.reconnect).forEach(this.clearReconnect, this);
-        const params = Object.values(this.instances).map(i => [i.coinInfo, i.postMessage]);
-        Object.values(this.instances).forEach(i => i.disconnect());
-        return Promise.all(params.map(p => this.getOrConnect(...p)));
+    reconnectAll(coin) {
+        const backends = Object.values(this.instances).filter(backend => !coin || coin.shortcut === backend.coinInfo.shortcut);
+        backends.forEach(i => i.disconnect());
+        return Promise.all(backends.map(this.getOrConnect, this));
     }
     isSupported(coinInfo) {
         const info = this.custom[coinInfo.shortcut] || coinInfo.blockchainLink;
@@ -66,11 +70,11 @@ class BackendManager {
         this.setPreferred(shortcut, undefined);
         delete this.custom[shortcut];
     }
-    setInstance(shortcut, instance) {
+    setInstance(coinIdentity, instance) {
         if (!instance)
-            delete this.instances[shortcut];
+            delete this.instances[coinIdentity];
         else
-            this.instances[shortcut] = instance;
+            this.instances[coinIdentity] = instance;
     }
     setPreferred(shortcut, url) {
         if (!url)
@@ -78,9 +82,10 @@ class BackendManager {
         else
             this.preferred[shortcut] = url;
     }
-    onDisconnect(coinInfo, postMessage, reconnectAttempt) {
+    onDisconnect({ coinInfo, postMessage, identity }, reconnectAttempt) {
         var _a;
-        this.setInstance(coinInfo.shortcut, undefined);
+        const coinIdentity = `${coinInfo.shortcut}/${identity !== null && identity !== void 0 ? identity : DEFAULT_IDENTITY}`;
+        this.setInstance(coinIdentity, undefined);
         if (reconnectAttempt === undefined || reconnectAttempt === 4) {
             this.setPreferred(coinInfo.shortcut, undefined);
         }
@@ -90,16 +95,16 @@ class BackendManager {
         const timeout = Math.min(2500 * reconnectAttempt, 20000);
         const time = Date.now() + timeout;
         const handle = setTimeout(() => {
-            this.getOrConnect(coinInfo, postMessage).catch(() => { });
+            this.getOrConnect({ coinInfo, postMessage, identity }).catch(() => { });
         }, timeout);
-        clearTimeout((_a = this.reconnect[coinInfo.shortcut]) === null || _a === void 0 ? void 0 : _a.handle);
-        this.reconnect[coinInfo.shortcut] = { attempts: reconnectAttempt + 1, handle };
-        postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.RECONNECTING, { coin: coinInfo, time }));
+        clearTimeout((_a = this.reconnect[coinIdentity]) === null || _a === void 0 ? void 0 : _a.handle);
+        this.reconnect[coinIdentity] = { attempts: reconnectAttempt + 1, handle };
+        postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.RECONNECTING, { coin: coinInfo, identity, time }));
     }
-    clearReconnect(shortcut) {
-        const reconnect = this.reconnect[shortcut];
+    clearReconnect(coinIdentity) {
+        const reconnect = this.reconnect[coinIdentity];
         clearTimeout(reconnect === null || reconnect === void 0 ? void 0 : reconnect.handle);
-        delete this.reconnect[shortcut];
+        delete this.reconnect[coinIdentity];
         return reconnect;
     }
     patchCoinInfo(coinInfo) {
@@ -116,6 +121,9 @@ class BackendManager {
             },
         };
     }
+    getReconnectFilter(coinInfo) {
+        return (key) => !coinInfo || key.startsWith(`${coinInfo.shortcut}/`);
+    }
 }
 exports.BackendManager = BackendManager;
 //# sourceMappingURL=BackendManager.js.map

package/lib/backend/Blockchain.d.ts

@@ -7,13 +7,15 @@ export type BlockchainOptions = {
     postMessage: (message: CoreEventMessage) => void;
     proxy?: Proxy;
     debug?: boolean;
+    identity?: string;
     onDisconnected?: (pendingSubscriptions?: boolean) => void;
 };
 export declare class Blockchain {
     link: BlockchainLink;
     serverInfo?: ServerInfo;
-    coinInfo: BlockchainOptions['coinInfo'];
-    postMessage: BlockchainOptions['postMessage'];
+    readonly identity?: string;
+    readonly coinInfo: BlockchainOptions['coinInfo'];
+    readonly postMessage: BlockchainOptions['postMessage'];
     feeForBlock: BlockchainLinkResponse<'estimateFee'>;
     feeTimestamp: number;
     private onDisconnected;
@@ -50,18 +52,27 @@ export declare class Blockchain {
         feePerTx?: string | undefined;
         feeLimit?: string | undefined;
     }[]>;
-    subscribe(accounts?: SubscriptionAccountInfo[]): Promise<{
+    subscribeBlocks(): Promise<{
+        subscribed: boolean;
+    }>;
+    subscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
         subscribed: boolean;
     }>;
     subscribeFiatRates(_currency?: string): Promise<{
         subscribed: boolean;
     }>;
-    unsubscribe(accounts?: SubscriptionAccountInfo[]): Promise<{
+    unsubscribeBlocks(): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
         subscribed: boolean;
     }>;
     unsubscribeFiatRates(): Promise<{
         subscribed: boolean;
     }>;
+    unsubscribeAll(): Promise<{
+        subscribed: boolean;
+    }>;
     pushTransaction(tx: string): Promise<string>;
     disconnect(): void;
 }

package/lib/backend/Blockchain.js

@@ -26,6 +26,7 @@ class Blockchain {
     constructor(options) {
         this.feeForBlock = [];
         this.feeTimestamp = 0;
+        this.identity = options.identity;
         this.coinInfo = options.coinInfo;
         this.postMessage = options.postMessage;
         this.onDisconnected = options.onDisconnected;
@@ -55,6 +56,7 @@ class Blockchain {
         this.link.dispose();
         this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.ERROR, {
             coin: this.coinInfo,
+            identity: this.identity,
             error: error.message,
             code: error.code,
         }));
@@ -74,10 +76,6 @@ class Blockchain {
         if (info.shortcut.toLowerCase() !== shortcut.toLowerCase()) {
             throw constants_1.ERRORS.TypedError('Backend_Invalid');
         }
-        this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.CONNECT, {
-            coin: this.coinInfo,
-            ...info,
-        }));
         this.link.on('disconnected', () => {
             this.onError(constants_1.ERRORS.TypedError('Backend_Disconnected'));
         });
@@ -87,10 +85,21 @@ class Blockchain {
         if (!this.initPromise) {
             this.initPromise = this.initLink()
                 .then(info => {
+                this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.CONNECT, {
+                    coin: this.coinInfo,
+                    identity: this.identity,
+                    ...info,
+                }));
                 this.initPromise = Promise.resolve(info);
                 return info;
             })
                 .catch(error => {
+                this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.ERROR, {
+                    coin: this.coinInfo,
+                    identity: this.identity,
+                    error: error.message,
+                    code: error.code,
+                }));
                 this.initPromise = Promise.reject(error);
                 this.link.dispose();
                 return this.initPromise;
@@ -143,7 +152,7 @@ class Blockchain {
         }
         return this.link.estimateFee(request);
     }
-    async subscribe(accounts) {
+    subscribeBlocks() {
         if (this.link.listenerCount('block') === 0) {
             this.link.on('block', block => {
                 this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.BLOCK, {
@@ -152,6 +161,9 @@ class Blockchain {
                 }));
             });
         }
+        return this.link.subscribe({ type: 'block' });
+    }
+    subscribeAccounts(accounts) {
         if (this.link.listenerCount('notification') === 0) {
             this.link.on('notification', notification => {
                 this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.NOTIFICATION, {
@@ -160,10 +172,6 @@ class Blockchain {
                 }));
             });
         }
-        const blockSubscription = await this.link.subscribe({ type: 'block' });
-        if (!accounts) {
-            return blockSubscription;
-        }
         return this.link.subscribe({
             type: 'accounts',
             accounts,
@@ -182,20 +190,22 @@ class Blockchain {
             type: 'fiatRates',
         });
     }
-    async unsubscribe(accounts) {
-        if (!accounts) {
-            this.link.removeAllListeners('block');
-            this.link.removeAllListeners('fiatRates');
-            this.link.removeAllListeners('notification');
-            await this.link.unsubscribe({ type: 'fiatRates' });
-            return this.link.unsubscribe({ type: 'block' });
-        }
+    unsubscribeBlocks() {
+        this.link.removeAllListeners('block');
+        return this.link.unsubscribe({ type: 'block' });
+    }
+    unsubscribeAccounts(accounts) {
         return this.link.unsubscribe({ type: 'accounts', accounts });
     }
     unsubscribeFiatRates() {
         this.link.removeAllListeners('fiatRates');
         return this.link.unsubscribe({ type: 'fiatRates' });
     }
+    async unsubscribeAll() {
+        this.link.removeAllListeners('notification');
+        await this.unsubscribeFiatRates();
+        return this.unsubscribeBlocks();
+    }
     pushTransaction(tx) {
         return this.link.pushTransaction(tx);
     }

package/lib/backend/BlockchainLink.d.ts

@@ -1,10 +1,10 @@
 import type { BlockchainOptions as Options } from './Blockchain';
 import type { CoinInfo } from '../types';
 export { Blockchain } from './Blockchain';
-export declare const findBackend: (coin: string) => import("./Blockchain").Blockchain | null;
+export declare const findBackend: (coin: string, identity?: string) => import("./Blockchain").Blockchain | null;
 export declare const setCustomBackend: (coinInfo: CoinInfo, blockchainLink: CoinInfo['blockchainLink']) => void;
 export declare const isBackendSupported: (coinInfo: CoinInfo) => void;
-export declare const initBlockchain: (coinInfo: CoinInfo, postMessage: Options['postMessage']) => Promise<import("./Blockchain").Blockchain>;
-export declare const reconnectAllBackends: () => Promise<import("./Blockchain").Blockchain[]>;
+export declare const initBlockchain: (coinInfo: CoinInfo, postMessage: Options['postMessage'], identity?: string) => Promise<import("./Blockchain").Blockchain>;
+export declare const reconnectAllBackends: (coinInfo?: CoinInfo) => Promise<import("./Blockchain").Blockchain[]>;
 export declare const dispose: () => void;
 //# sourceMappingURL=BlockchainLink.d.ts.map

package/lib/backend/BlockchainLink.js

@@ -5,7 +5,7 @@ const BackendManager_1 = require("./BackendManager");
 var Blockchain_1 = require("./Blockchain");
 Object.defineProperty(exports, "Blockchain", { enumerable: true, get: function () { return Blockchain_1.Blockchain; } });
 const backends = new BackendManager_1.BackendManager();
-const findBackend = (coin) => backends.get(coin);
+const findBackend = (coin, identity) => backends.get(coin, identity);
 exports.findBackend = findBackend;
 const setCustomBackend = (coinInfo, blockchainLink) => (blockchainLink === null || blockchainLink === void 0 ? void 0 : blockchainLink.url.length)
     ? backends.setCustom(coinInfo.shortcut, blockchainLink)
@@ -13,9 +13,9 @@ const setCustomBackend = (coinInfo, blockchainLink) => (blockchainLink === null
 exports.setCustomBackend = setCustomBackend;
 const isBackendSupported = (coinInfo) => backends.isSupported(coinInfo);
 exports.isBackendSupported = isBackendSupported;
-const initBlockchain = (coinInfo, postMessage) => backends.getOrConnect(coinInfo, postMessage);
+const initBlockchain = (coinInfo, postMessage, identity) => backends.getOrConnect({ coinInfo, identity, postMessage });
 exports.initBlockchain = initBlockchain;
-const reconnectAllBackends = () => backends.reconnectAll();
+const reconnectAllBackends = (coinInfo) => backends.reconnectAll(coinInfo);
 exports.reconnectAllBackends = reconnectAllBackends;
 const dispose = () => backends.dispose();
 exports.dispose = dispose;

package/lib/constants/errors.d.ts

@@ -33,6 +33,7 @@ export declare const ERROR_CODES: {
     Device_UsedElsewhere: string;
     Device_InvalidState: string;
     Device_CallInProgress: string;
+    Device_MultipleNotSupported: string;
 };
 export declare class TrezorError extends Error {
     code: string;

package/lib/constants/errors.js

@@ -36,6 +36,7 @@ exports.ERROR_CODES = {
     Device_UsedElsewhere: 'Device is used in another window',
     Device_InvalidState: 'Passphrase is incorrect',
     Device_CallInProgress: 'Device call in progress',
+    Device_MultipleNotSupported: 'Multiple devices are not supported',
 };
 class TrezorError extends Error {
     constructor(code, message) {

package/lib/core/AbstractMethod.d.ts

@@ -1,6 +1,5 @@
-import { Deferred } from '@trezor/utils';
 import { NETWORK } from '../constants';
-import { CallMethodPayload, CallMethodResponse, UiRequestButtonData, UiPromiseCreator, CoreEventMessage } from '../events';
+import { CallMethodPayload, CallMethodResponse, UiRequestButtonData, UiPromiseCreator, CoreEventMessage, UiRequestConfirmation } from '../events';
 import type { Device } from '../device/Device';
 import type { FirmwareRange } from '../types';
 export type Payload<M> = Extract<CallMethodPayload, {
@@ -25,6 +24,7 @@ export declare abstract class AbstractMethod<Name extends CallMethodPayload['met
     name: Name;
     payload: Payload<Name>;
     get info(): string;
+    get confirmation(): UiRequestConfirmation['payload'] | undefined;
     useUi: boolean;
     useDevice: boolean;
     useDeviceState: boolean;
@@ -37,24 +37,20 @@ export declare abstract class AbstractMethod<Name extends CallMethodPayload['met
     requireDeviceMode: string[];
     network: NETWORK.NetworkType;
     useCardanoDerivation: boolean;
-    confirmation?(): Promise<boolean | undefined>;
-    noBackupConfirmation?(allowSuppression?: boolean): Promise<boolean>;
+    noBackupConfirmationMode: 'never' | 'always' | 'popup-only';
     getButtonRequestData?(code: string): UiRequestButtonData | undefined;
     postMessage: (message: CoreEventMessage) => void;
-    getPopupPromise: () => Deferred<void>;
     createUiPromise: UiPromiseCreator;
-    removeUiPromise: (promise: Deferred<any>) => void;
     initAsync?(): Promise<void>;
     constructor(message: {
         id?: number;
         payload: Payload<Name>;
     });
     setDevice(device: Device): void;
-    requestPermissions(): Promise<boolean>;
     private getOriginPermissions;
     checkPermissions(): void;
     savePermissions(temporary?: boolean): void;
-    checkFirmwareRange(isUsingPopup?: boolean): Promise<"ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined>;
+    checkFirmwareRange(): "ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined;
     isManagementRestricted(): boolean | undefined;
     abstract init(): void;
     abstract run(): Promise<MethodReturnType<Name>>;

package/lib/core/AbstractMethod.js

@@ -11,11 +11,15 @@ exports.DEFAULT_FIRMWARE_RANGE = {
     T1B1: { min: '1.0.0', max: '0' },
     T2T1: { min: '2.0.0', max: '0' },
     T2B1: { min: '2.6.1', max: '0' },
+    T3T1: { min: '2.7.1', max: '0' },
 };
 class AbstractMethod {
     get info() {
         return '';
     }
+    get confirmation() {
+        return undefined;
+    }
     constructor(message) {
         var _a, _b;
         const { payload } = message;
@@ -58,6 +62,7 @@ class AbstractMethod {
             typeof payload.useCardanoDerivation === 'boolean'
                 ? payload.useCardanoDerivation
                 : payload.method.startsWith('cardano');
+        this.noBackupConfirmationMode = 'never';
     }
     setDevice(device) {
         this.device = device;
@@ -65,21 +70,6 @@ class AbstractMethod {
         const originalFn = this.createUiPromise;
         this.createUiPromise = (t, d) => originalFn(t, d || device);
     }
-    async requestPermissions() {
-        await this.getPopupPromise().promise;
-        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_PERMISSION);
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_PERMISSION, {
-            permissions: this.requiredPermissions,
-            device: this.device.toMessageObject(),
-        }));
-        const uiResp = await uiPromise.promise;
-        const { granted, remember } = uiResp.payload;
-        if (granted) {
-            this.savePermissions(!remember);
-            return true;
-        }
-        return false;
-    }
     getOriginPermissions() {
         var _a;
         const origin = DataManager_1.DataManager.getSettings('origin');
@@ -127,7 +117,7 @@ class AbstractMethod {
             this.postMessage((0, events_1.createDeviceMessage)(events_1.DEVICE.CONNECT, this.device.toMessageObject()));
         }
     }
-    async checkFirmwareRange(isUsingPopup) {
+    checkFirmwareRange() {
         if (this.skipFirmwareCheck) {
             return;
         }
@@ -150,18 +140,7 @@ class AbstractMethod {
             return events_1.UI.FIRMWARE_OLD;
         }
         if (range.max !== '0' && utils_1.versionUtils.isNewer(version, range.max)) {
-            if (isUsingPopup) {
-                await this.getPopupPromise().promise;
-                const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
-                this.postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_NOT_COMPATIBLE, device.toMessageObject()));
-                const uiResp = await uiPromise.promise;
-                if (!uiResp.payload) {
-                    throw constants_1.ERRORS.TypedError('Method_PermissionsNotGranted');
-                }
-            }
-            else {
-                return events_1.UI.FIRMWARE_NOT_COMPATIBLE;
-            }
+            return events_1.UI.FIRMWARE_NOT_COMPATIBLE;
         }
     }
     isManagementRestricted() {

package/lib/core/index.d.ts

@@ -5,8 +5,9 @@ import { AbstractMethod } from './AbstractMethod';
 import { LogWriter } from '../utils/debug';
 import type { ConnectSettings } from '../types';
 export declare class Core extends EventEmitter {
+    abortController: AbortController;
     handleMessage(message: CoreRequestMessage): void;
-    dispose(): Promise<void>;
+    dispose(): void;
     getCurrentMethod(): Promise<AbstractMethod<any, undefined>>;
     getTransportInfo(): TransportInfo | undefined;
     enumerate(): void;