@trezor/connect 9.1.11 → 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

@@ -1,14 +1,13 @@
 import BlockchainLink, { ServerInfo, SubscriptionAccountInfo, BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
-import { PostMessage } from '../events';
+import { CoreEventMessage } from '../events';
 import { ERRORS } from '../constants';
 import type { CoinInfo, Proxy } from '../types';
 export type BlockchainOptions = {
     coinInfo: CoinInfo;
-    postMessage: PostMessage;
+    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,6 +1,6 @@
-import { Deferred } from '@trezor/utils/lib/createDeferred';
+import { Deferred } from '@trezor/utils';
 import { NETWORK } from '../constants';
-import { CallMethodPayload, CallMethodResponse, UiRequestButtonData, UiPromiseCreator, PostMessage } from '../events';
+import { CallMethodPayload, CallMethodResponse, UiRequestButtonData, UiPromiseCreator, CoreEventMessage } from '../events';
 import type { Device } from '../device/Device';
 import type { FirmwareRange } from '../types';
 export type Payload<M> = Extract<CallMethodPayload, {
@@ -40,18 +40,18 @@ export declare abstract class AbstractMethod<Name extends CallMethodPayload['met
     confirmation?(): Promise<boolean | undefined>;
     noBackupConfirmation?(allowSuppression?: boolean): Promise<boolean>;
     getButtonRequestData?(code: string): UiRequestButtonData | undefined;
-    postMessage: PostMessage;
+    postMessage: (message: CoreEventMessage) => void;
     getPopupPromise: () => Deferred<void>;
     createUiPromise: UiPromiseCreator;
     removeUiPromise: (promise: Deferred<any>) => void;
     initAsync?(): Promise<void>;
-    initAsyncPromise?: 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>;

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");
@@ -81,47 +80,49 @@ class AbstractMethod {
         }
         return false;
     }
+    getOriginPermissions() {
+        var _a;
+        const origin = DataManager_1.DataManager.getSettings('origin');
+        if (!origin) {
+            return [];
+        }
+        return ((_a = connect_common_1.storage.loadForOrigin(origin)) === null || _a === void 0 ? void 0 : _a.permissions) || [];
+    }
     checkPermissions() {
-        const savedPermissions = connect_common_1.storage.load().permissions;
+        const originPermissions = this.getOriginPermissions();
         let notPermitted = [...this.requiredPermissions];
-        if (savedPermissions) {
-            const originPermissions = savedPermissions.filter(p => p.origin === DataManager_1.DataManager.getSettings('origin'));
-            if (originPermissions.length > 0) {
-                notPermitted = notPermitted.filter(np => {
-                    const granted = originPermissions.find(p => p.type === np && p.device === this.device.features.device_id);
-                    return !granted;
-                });
-            }
+        if (originPermissions.length > 0) {
+            notPermitted = notPermitted.filter(np => {
+                const granted = originPermissions.find(p => p.type === np && p.device === this.device.features.device_id);
+                return !granted;
+            });
         }
         this.requiredPermissions = notPermitted;
     }
     savePermissions(temporary = false) {
-        const savedPermissions = connect_common_1.storage.load(temporary).permissions || [];
+        const originPermissions = this.getOriginPermissions();
         let permissionsToSave = this.requiredPermissions.map(p => ({
-            origin: DataManager_1.DataManager.getSettings('origin'),
             type: p,
             device: this.device.features.device_id || undefined,
         }));
         let emitEvent = false;
         if (this.requiredPermissions.indexOf('read') >= 0) {
-            const wasAlreadyGranted = savedPermissions.filter(p => p.origin === DataManager_1.DataManager.getSettings('origin') &&
-                p.type === 'read' &&
-                p.device === this.device.features.device_id);
+            const wasAlreadyGranted = originPermissions.filter(p => p.type === 'read' && p.device === this.device.features.device_id);
             if (wasAlreadyGranted.length < 1) {
                 emitEvent = true;
             }
         }
-        const originPermissions = savedPermissions.filter(p => p.origin === DataManager_1.DataManager.getSettings('origin'));
         if (originPermissions.length > 0) {
             permissionsToSave = permissionsToSave.filter(p2s => {
                 const granted = originPermissions.find(p => p.type === p2s.type && p.device === p2s.device);
                 return !granted;
             });
         }
-        connect_common_1.storage.save(state => ({
+        const origin = DataManager_1.DataManager.getSettings('origin');
+        connect_common_1.storage.saveForOrigin(state => ({
             ...state,
-            permissions: savedPermissions.concat(permissionsToSave),
-        }), temporary);
+            permissions: [...(state.permissions || []), ...permissionsToSave],
+        }), origin, temporary);
         if (emitEvent) {
             this.postMessage((0, events_1.createDeviceMessage)(events_1.DEVICE.CONNECT, this.device.toMessageObject()));
         }
@@ -145,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.d.ts

@@ -1,18 +1,15 @@
 /// <reference types="node" />
 import EventEmitter from 'events';
-import { TransportInfo, CoreMessage } from '../events';
+import { TransportInfo, CoreRequestMessage, CoreEventMessage } from '../events';
 import { AbstractMethod } from './AbstractMethod';
 import { LogWriter } from '../utils/debug';
 import type { ConnectSettings } from '../types';
-export declare const handleMessage: (message: CoreMessage) => void;
-export declare const onCall: (message: CoreMessage) => Promise<void>;
 export declare class Core extends EventEmitter {
-    handleMessage(message: any): void;
+    handleMessage(message: CoreRequestMessage): void;
     dispose(): Promise<void>;
     getCurrentMethod(): Promise<AbstractMethod<any, undefined>>;
     getTransportInfo(): TransportInfo | undefined;
     enumerate(): void;
 }
-export declare const initCore: (settings: ConnectSettings, logWriterFactory?: () => LogWriter | undefined) => Promise<Core>;
-export declare const initTransport: (settings: ConnectSettings) => Promise<void>;
+export declare const initCore: (settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: () => LogWriter | undefined) => Promise<Core>;
 //# sourceMappingURL=index.d.ts.map