@trezor/connect 9.1.12 → 9.2.0

package/lib/backend/BackendManager.js

@@ -4,46 +4,51 @@ exports.BackendManager = void 0;
 const DataManager_1 = require("../data/DataManager");
 const constants_1 = require("../constants");
 const Blockchain_1 = require("./Blockchain");
+const events_1 = require("../events");
 class BackendManager {
     constructor() {
         this.instances = {};
         this.custom = {};
         this.preferred = {};
+        this.reconnect = {};
     }
     get(shortcut) {
         var _a;
         return (_a = this.instances[shortcut]) !== null && _a !== void 0 ? _a : null;
     }
-    remove(shortcut) {
-        delete this.instances[shortcut];
-    }
     async getOrConnect(coinInfo, postMessage) {
-        let backend = this.get(coinInfo.shortcut);
+        let backend = this.instances[coinInfo.shortcut];
         if (!backend) {
             backend = new Blockchain_1.Blockchain({
                 coinInfo: this.patchCoinInfo(coinInfo),
                 postMessage,
                 debug: DataManager_1.DataManager.getSettings('debug'),
                 proxy: DataManager_1.DataManager.getSettings('proxy'),
-                onConnected: url => this.setPreferred(coinInfo.shortcut, url),
-                onDisconnected: () => this.remove(coinInfo.shortcut),
+                onDisconnected: this.onDisconnected.bind(this),
             });
-            this.instances[coinInfo.shortcut] = backend;
-            try {
-                await backend.init();
-            }
-            catch (error) {
-                this.remove(coinInfo.shortcut);
-                this.removePreferred(coinInfo.shortcut);
-                throw error;
+            this.setInstance(coinInfo.shortcut, backend);
+        }
+        const reconnect = this.clearReconnect(coinInfo.shortcut);
+        try {
+            const info = await backend.init();
+            this.setPreferred(coinInfo.shortcut, info.url);
+            return backend;
+        }
+        catch (error) {
+            this.setInstance(coinInfo.shortcut, undefined);
+            this.setPreferred(coinInfo.shortcut, undefined);
+            if (reconnect) {
+                this.planReconnect(backend.coinInfo, backend.postMessage, reconnect.attempts);
             }
+            throw error;
         }
-        return backend;
     }
     dispose() {
+        Object.keys(this.reconnect).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)));
@@ -55,18 +60,47 @@ class BackendManager {
         }
     }
     setCustom(shortcut, blockchainLink) {
-        this.removePreferred(shortcut);
+        this.setPreferred(shortcut, undefined);
         this.custom[shortcut] = blockchainLink;
     }
     removeCustom(shortcut) {
-        this.removePreferred(shortcut);
+        this.setPreferred(shortcut, undefined);
         delete this.custom[shortcut];
     }
+    setInstance(shortcut, instance) {
+        if (!instance)
+            delete this.instances[shortcut];
+        else
+            this.instances[shortcut] = instance;
+    }
     setPreferred(shortcut, url) {
-        this.preferred[shortcut] = url;
+        if (!url)
+            delete this.preferred[shortcut];
+        else
+            this.preferred[shortcut] = url;
     }
-    removePreferred(shortcut) {
-        delete this.preferred[shortcut];
+    planReconnect(coinInfo, postMessage, attempts) {
+        var _a;
+        const timeout = Math.min(2500 * attempts, 20000);
+        const time = Date.now() + timeout;
+        const handle = setTimeout(() => {
+            this.getOrConnect(coinInfo, postMessage).catch(() => { });
+        }, timeout);
+        clearTimeout((_a = this.reconnect[coinInfo.shortcut]) === null || _a === void 0 ? void 0 : _a.handle);
+        this.reconnect[coinInfo.shortcut] = { attempts: attempts + 1, handle };
+        postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.RECONNECTING, { coin: coinInfo, time }));
+    }
+    clearReconnect(shortcut) {
+        const reconnect = this.reconnect[shortcut];
+        clearTimeout(reconnect === null || reconnect === void 0 ? void 0 : reconnect.handle);
+        delete this.reconnect[shortcut];
+        return reconnect;
+    }
+    onDisconnected(backend, pendingSubscriptions) {
+        this.setInstance(backend.coinInfo.shortcut, undefined);
+        if (pendingSubscriptions) {
+            this.planReconnect(backend.coinInfo, backend.postMessage, 0);
+        }
     }
     patchCoinInfo(coinInfo) {
         var _a, _b;

package/lib/backend/Blockchain.d.ts

@@ -7,8 +7,7 @@ export type BlockchainOptions = {
     postMessage: (message: CoreEventMessage) => void;
     proxy?: Proxy;
     debug?: boolean;
-    onConnected?: (url: string) => void;
-    onDisconnected?: () => void;
+    onDisconnected?: (backend: Blockchain, pendingSubscriptions?: boolean) => void;
 };
 export declare class Blockchain {
     link: BlockchainLink;
@@ -17,11 +16,12 @@ export declare class Blockchain {
     postMessage: BlockchainOptions['postMessage'];
     feeForBlock: BlockchainLinkResponse<'estimateFee'>;
     feeTimestamp: number;
-    private onConnected;
     private onDisconnected;
+    private initPromise?;
     constructor(options: BlockchainOptions);
     onError(error: ERRORS.TrezorError): void;
-    init(): Promise<void>;
+    private initLink;
+    init(): Promise<ServerInfo>;
     getTransactions(txs: string[]): Promise<import("@trezor/blockchain-link").Transaction[]>;
     getTransactionHexes(txids: string[]): Promise<string[]>;
     getCurrentFiatRates(params: {
@@ -29,7 +29,7 @@ export declare class Blockchain {
         token?: string;
     }): Promise<{
         ts: number;
-        rates: import("@trezor/blockchain-link").FiatRates;
+        rates: import("@trezor/blockchain-link").FiatRatesLegacy;
     }>;
     getFiatRatesForTimestamps(params: {
         currencies?: string[];
@@ -38,7 +38,7 @@ export declare class Blockchain {
     }): Promise<{
         tickers: {
             ts: number;
-            rates: import("@trezor/blockchain-link").FiatRates;
+            rates: import("@trezor/blockchain-link").FiatRatesLegacy;
         }[];
     }>;
     getAccountBalanceHistory(params: BlockchainLinkParams<'getAccountBalanceHistory'>): Promise<import("@trezor/blockchain-link").AccountBalanceHistory[]>;

package/lib/backend/Blockchain.js

@@ -28,7 +28,6 @@ class Blockchain {
         this.feeTimestamp = 0;
         this.coinInfo = options.coinInfo;
         this.postMessage = options.postMessage;
-        this.onConnected = options.onConnected;
         this.onDisconnected = options.onDisconnected;
         const { blockchainLink } = options.coinInfo;
         if (!blockchainLink) {
@@ -50,43 +49,54 @@ class Blockchain {
     }
     onError(error) {
         var _a;
+        const pendingSubscriptions = this.link.listenerCount('block') ||
+            this.link.listenerCount('notification') ||
+            this.link.listenerCount('fiatRates');
         this.link.dispose();
         this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.ERROR, {
             coin: this.coinInfo,
             error: error.message,
             code: error.code,
         }));
-        (_a = this.onDisconnected) === null || _a === void 0 ? void 0 : _a.call(this);
-    }
-    async init() {
-        this.link.on('connected', async () => {
-            var _a;
-            const info = await this.link.getInfo();
-            this.serverInfo = info;
-            const shortcut = this.coinInfo.shortcut === 'tXRP' ? 'XRP' : this.coinInfo.shortcut;
-            if (info.shortcut.toLowerCase() !== shortcut.toLowerCase()) {
-                this.onError(constants_1.ERRORS.TypedError('Backend_Invalid'));
-                return;
-            }
-            (_a = this.onConnected) === null || _a === void 0 ? void 0 : _a.call(this, info.url);
-            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'));
-        });
-        this.link.on('error', error => {
-            this.onError(constants_1.ERRORS.TypedError('Backend_Error', error.message));
-        });
+        (_a = this.onDisconnected) === null || _a === void 0 ? void 0 : _a.call(this, this, !!pendingSubscriptions);
+    }
+    async initLink() {
+        let info;
         try {
             await this.link.connect();
+            info = await this.link.getInfo();
         }
         catch (error) {
-            this.onError(constants_1.ERRORS.TypedError('Backend_Error', error.message));
-            throw error;
+            throw constants_1.ERRORS.TypedError('Backend_Error', error.message);
+        }
+        this.serverInfo = info;
+        const shortcut = this.coinInfo.shortcut === 'tXRP' ? 'XRP' : this.coinInfo.shortcut;
+        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'));
+        });
+        return info;
+    }
+    init() {
+        if (!this.initPromise) {
+            this.initPromise = this.initLink()
+                .then(info => {
+                this.initPromise = Promise.resolve(info);
+                return info;
+            })
+                .catch(error => {
+                this.initPromise = Promise.reject(error);
+                this.link.dispose();
+                return this.initPromise;
+            });
         }
+        return this.initPromise;
     }
     getTransactions(txs) {
         return Promise.all(txs.map(id => this.link.getTransaction(id)));

package/lib/constants/index.d.ts

@@ -2,5 +2,5 @@ export * as ERRORS from './errors';
 export * as NETWORK from './network';
 export * as CARDANO from './cardano';
 export * as NEM from './nem';
-export * as PROTO from '@trezor/protobuf/lib/messages-schema';
+export { MessagesSchema as PROTO } from '@trezor/protobuf';
 //# sourceMappingURL=index.d.ts.map

package/lib/constants/index.js

@@ -6,5 +6,6 @@ exports.ERRORS = tslib_1.__importStar(require("./errors"));
 exports.NETWORK = tslib_1.__importStar(require("./network"));
 exports.CARDANO = tslib_1.__importStar(require("./cardano"));
 exports.NEM = tslib_1.__importStar(require("./nem"));
-exports.PROTO = tslib_1.__importStar(require("@trezor/protobuf/lib/messages-schema"));
+var protobuf_1 = require("@trezor/protobuf");
+Object.defineProperty(exports, "PROTO", { enumerable: true, get: function () { return protobuf_1.MessagesSchema; } });
 //# sourceMappingURL=index.js.map

package/lib/core/AbstractMethod.d.ts

@@ -1,4 +1,4 @@
-import { Deferred } from '@trezor/utils/lib/createDeferred';
+import { Deferred } from '@trezor/utils';
 import { NETWORK } from '../constants';
 import { CallMethodPayload, CallMethodResponse, UiRequestButtonData, UiPromiseCreator, CoreEventMessage } from '../events';
 import type { Device } from '../device/Device';

package/lib/core/AbstractMethod.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractMethod = exports.DEFAULT_FIRMWARE_RANGE = void 0;
-const tslib_1 = require("tslib");
 const connect_common_1 = require("@trezor/connect-common");
-const versionUtils = tslib_1.__importStar(require("@trezor/utils/lib/versionUtils"));
+const utils_1 = require("@trezor/utils");
 const DataManager_1 = require("../data/DataManager");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
@@ -147,10 +146,10 @@ class AbstractMethod {
         }
         const version = device.getVersion().join('.');
         if (device.firmwareStatus === 'required' ||
-            !versionUtils.isNewerOrEqual(version, range.min)) {
+            !utils_1.versionUtils.isNewerOrEqual(version, range.min)) {
             return events_1.UI.FIRMWARE_OLD;
         }
-        if (range.max !== '0' && versionUtils.isNewer(version, range.max)) {
+        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);

package/lib/core/index.js

@@ -4,8 +4,8 @@ exports.initCore = exports.Core = void 0;
 const tslib_1 = require("tslib");
 const events_1 = tslib_1.__importDefault(require("events"));
 const transport_1 = require("@trezor/transport");
-const createDeferred_1 = require("@trezor/utils/lib/createDeferred");
-const getSynchronize_1 = require("@trezor/utils/lib/getSynchronize");
+const utils_1 = require("@trezor/utils");
+const utils_2 = require("@trezor/utils");
 const connect_common_1 = require("@trezor/connect-common");
 const DataManager_1 = require("../data/DataManager");
 const DeviceList_1 = require("../device/DeviceList");
@@ -25,13 +25,17 @@ const _callMethods = [];
 let _interactionTimeout;
 let _deviceListInitTimeout;
 let _overridePromise;
-const methodSynchronize = (0, getSynchronize_1.getSynchronize)();
+const methodSynchronize = (0, utils_2.getSynchronize)();
+let waitForFirstMethod = (0, utils_1.createDeferred)();
 const _log = (0, debug_1.initLog)('Core');
 const postMessage = (message) => {
     if (message.event === events_2.RESPONSE_EVENT) {
         const index = _callMethods.findIndex(call => call && call.responseID === message.id);
         if (index >= 0) {
             _callMethods.splice(index, 1);
+            if (_callMethods.length === 0) {
+                waitForFirstMethod = (0, utils_1.createDeferred)();
+            }
         }
     }
     _core.emit(events_2.CORE_EVENT, message);
@@ -41,7 +45,7 @@ const getPopupPromise = (requestWindow = true) => {
         postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_UI_WINDOW));
     }
     if (!_popupPromise) {
-        _popupPromise = (0, createDeferred_1.createDeferred)();
+        _popupPromise = (0, utils_1.createDeferred)();
     }
     return _popupPromise;
 };
@@ -50,7 +54,7 @@ const interactionTimeout = () => _interactionTimeout.start(() => {
 });
 const createUiPromise = (promiseEvent, device) => {
     const uiPromise = {
-        ...(0, createDeferred_1.createDeferred)(promiseEvent),
+        ...(0, utils_1.createDeferred)(promiseEvent),
         device,
     };
     _uiPromises.push(uiPromise);
@@ -108,6 +112,7 @@ const initDevice = async (method) => {
     const isWebUsb = _deviceList.transportType() === 'WebUsbTransport';
     let device;
     let showDeviceSelection = isWebUsb;
+    const isUsingPopup = DataManager_1.DataManager.getSettings('popup');
     const origin = DataManager_1.DataManager.getSettings('origin');
     const { preferredDevice } = connect_common_1.storage.load().origin[origin] || {};
     const preferredDeviceInList = preferredDevice && _deviceList.getDevice(preferredDevice.path);
@@ -119,13 +124,14 @@ const initDevice = async (method) => {
     }
     if (method.devicePath) {
         device = _deviceList.getDevice(method.devicePath);
-        showDeviceSelection = !device || !!(device === null || device === void 0 ? void 0 : device.unreadableError);
+        showDeviceSelection =
+            !device || !!(device === null || device === void 0 ? void 0 : device.unreadableError) || (device.isUnacquired() && !!isUsingPopup);
     }
     else {
         const devices = _deviceList.asArray();
         if (devices.length === 1 && !isWebUsb) {
             device = _deviceList.getDevice(devices[0].path);
-            showDeviceSelection = !!(device === null || device === void 0 ? void 0 : device.unreadableError);
+            showDeviceSelection = !!(device === null || device === void 0 ? void 0 : device.unreadableError) || device.isUnacquired();
         }
         else {
             showDeviceSelection = true;
@@ -138,7 +144,10 @@ const initDevice = async (method) => {
             throw constants_1.ERRORS.TypedError('Transport_Missing');
         }
         const devices = _deviceList.asArray();
-        if (devices.length === 1 && devices[0].type !== 'unreadable' && !isWebUsb) {
+        if (devices.length === 1 &&
+            devices[0].type !== 'unreadable' &&
+            devices[0].features &&
+            !isWebUsb) {
             device = _deviceList.getDevice(devices[0].path);
         }
         else {
@@ -196,6 +205,7 @@ const onCall = async (message) => {
             await ((_a = method.initAsync) === null || _a === void 0 ? void 0 : _a.call(method));
             return method;
         });
+        waitForFirstMethod.resolve();
         _callMethods.push(method);
     }
     catch (error) {
@@ -414,7 +424,7 @@ const onCall = async (message) => {
         }
         const response = messageResponse;
         if (response) {
-            if (method.device.isT1() && method.name === 'rebootToBootloader' && response.success) {
+            if (method.name === 'rebootToBootloader' && response.success) {
                 await (0, promiseUtils_1.resolveAfter)(1000).promise;
                 try {
                     await device.run(() => Promise.resolve(), { skipFinalReload: true });
@@ -517,6 +527,7 @@ const onPopupClosed = (customErrorMessage) => {
                         postMessage((0, events_2.createResponseMessage)(m.responseID, false, { error }));
                     });
                     _callMethods.splice(0, _callMethods.length);
+                    waitForFirstMethod = (0, utils_1.createDeferred)();
                 }
             }
         });
@@ -640,8 +651,9 @@ class Core extends events_1.default {
             await _deviceList.dispose();
         }
     }
-    getCurrentMethod() {
-        return methodSynchronize(() => _callMethods[0]);
+    async getCurrentMethod() {
+        await waitForFirstMethod.promise;
+        return await methodSynchronize(() => _callMethods[0]);
     }
     getTransportInfo() {
         if (!_deviceList) {

package/lib/data/DataManager.d.ts

@@ -1,13 +1,13 @@
 import { ConnectSettings } from '../types';
 type AssetCollection = {
-    [key: string]: JSON;
+    [key: string]: Record<string, any>;
 };
 export declare class DataManager {
     static assets: AssetCollection;
     private static settings;
     private static messages;
     static load(settings: ConnectSettings, withAssets?: boolean): Promise<void>;
-    static getProtobufMessages(): JSON;
+    static getProtobufMessages(): Record<string, any>;
     static getSettings(key?: undefined): ConnectSettings;
     static getSettings<T extends keyof ConnectSettings>(key: T): ConnectSettings[T];
     static getConfig(): {