@trezor/connect 9.2.0 → 9.2.2

package/lib/api/getPublicKey.d.ts

@@ -15,24 +15,26 @@ export default class GetPublicKey extends AbstractMethod<'getPublicKey', Params[
     noBackupConfirmation(allowSuppression?: boolean): Promise<boolean>;
     run(): Promise<{
         xpubSegwit?: string | undefined;
+        descriptorChecksum?: string | undefined;
         path: number[];
-        depth: number;
-        fingerprint: number;
-        xpub: string;
         publicKey: string;
         serializedPath: string;
+        depth: number;
+        fingerprint: number;
         chainCode: string;
         childNum: number;
+        xpub: string;
     } | {
         xpubSegwit?: string | undefined;
+        descriptorChecksum?: string | undefined;
         path: number[];
-        depth: number;
-        fingerprint: number;
-        xpub: string;
         publicKey: string;
         serializedPath: string;
+        depth: number;
+        fingerprint: number;
         chainCode: string;
         childNum: number;
+        xpub: string;
     }[]>;
 }
 export {};

package/lib/api/nem/nemSignTx.d.ts

@@ -2,14 +2,6 @@ import { PROTO } from '../../constants';
 import * as $T from '../../types/api/nem';
 export declare const createTx: (tx: $T.NEMTransaction, address_n: number[], chunkify?: boolean) => {
     chunkify?: boolean | undefined;
-    multisig?: {
-        address_n?: number[] | undefined;
-        network?: number | undefined;
-        signer?: string | undefined;
-        timestamp: number;
-        fee: string | number;
-        deadline: number;
-    } | undefined;
     transfer?: {
         public_key?: string | undefined;
         payload?: string | undefined;
@@ -21,6 +13,14 @@ export declare const createTx: (tx: $T.NEMTransaction, address_n: number[], chun
         amount: string | number;
         recipient: string;
     } | undefined;
+    multisig?: {
+        address_n?: number[] | undefined;
+        network?: number | undefined;
+        signer?: string | undefined;
+        timestamp: number;
+        fee: string | number;
+        deadline: number;
+    } | undefined;
     cosigning?: boolean | undefined;
     provision_namespace?: {
         parent?: string | undefined;
@@ -32,17 +32,17 @@ export declare const createTx: (tx: $T.NEMTransaction, address_n: number[], chun
         fee: string | number;
         sink: string;
         definition: {
-            fee?: string | number | undefined;
             name?: string | undefined;
-            ticker?: string | undefined;
-            divisibility?: number | undefined;
+            fee?: string | number | undefined;
             levy?: PROTO.NEMMosaicLevy | undefined;
+            divisibility?: number | undefined;
+            transferable?: boolean | undefined;
+            ticker?: string | undefined;
             levy_address?: string | undefined;
             levy_namespace?: string | undefined;
             levy_mosaic?: string | undefined;
             supply?: number | undefined;
             mutable_supply?: boolean | undefined;
-            transferable?: boolean | undefined;
             networks?: number[] | undefined;
             description: string;
             namespace: string;
@@ -51,9 +51,9 @@ export declare const createTx: (tx: $T.NEMTransaction, address_n: number[], chun
     } | undefined;
     supply_change?: {
         type: PROTO.NEMSupplyChangeType;
+        delta: number;
         namespace: string;
         mosaic: string;
-        delta: number;
     } | undefined;
     aggregate_modification?: {
         modifications?: {

package/lib/api/stellar/stellarSignTx.d.ts

@@ -1,7 +1,7 @@
 import type { TypedCall } from '../../device/DeviceCommands';
 import { StellarTransaction } from '../../types/api/stellar';
 export declare const stellarSignTx: (typedCall: TypedCall, address_n: number[], networkPassphrase: string, tx: StellarTransaction) => Promise<{
-    public_key: string;
     signature: string;
+    public_key: string;
 }>;
 //# sourceMappingURL=stellarSignTx.d.ts.map

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

@@ -18,31 +18,20 @@ export declare const createTx: (address_n: number[], branch: string, operation:
         source: Uint8Array;
         amount: string | number;
         fee: string | number;
-        gas_limit: number;
         destination: {
             hash: Uint8Array;
             tag: number;
         };
         counter: number;
+        gas_limit: number;
         storage_limit: number;
     } | undefined;
-    proposal?: {
-        source: string;
-        period: number;
-        proposals: string[];
-    } | undefined;
-    ballot?: {
-        source: string;
-        period: number;
-        proposal: string;
-        ballot: PROTO.TezosBallotType;
-    } | undefined;
     reveal?: {
-        public_key: Uint8Array;
         source: Uint8Array;
+        public_key: Uint8Array;
         fee: string | number;
-        gas_limit: number;
         counter: number;
+        gas_limit: number;
         storage_limit: number;
     } | undefined;
     origination?: {
@@ -51,20 +40,31 @@ export declare const createTx: (address_n: number[], branch: string, operation:
         spendable?: boolean | undefined;
         delegatable?: boolean | undefined;
         source: Uint8Array;
-        script: string | number[];
         fee: string | number;
-        gas_limit: number;
+        script: string | number[];
         counter: number;
+        gas_limit: number;
         storage_limit: number;
         balance: number;
     } | undefined;
     delegation?: {
         source: Uint8Array;
         fee: string | number;
-        delegate: Uint8Array;
-        gas_limit: number;
         counter: number;
+        gas_limit: number;
         storage_limit: number;
+        delegate: Uint8Array;
+    } | undefined;
+    proposal?: {
+        source: string;
+        period: number;
+        proposals: string[];
+    } | undefined;
+    ballot?: {
+        source: string;
+        period: number;
+        proposal: string;
+        ballot: PROTO.TezosBallotType;
     } | undefined;
     address_n: number[];
     branch: Uint8Array;

package/lib/backend/BackendManager.d.ts

@@ -15,9 +15,8 @@ export declare class BackendManager {
     removeCustom(shortcut: CoinShortcut): void;
     private setInstance;
     private setPreferred;
-    private planReconnect;
+    private onDisconnect;
     private clearReconnect;
-    private onDisconnected;
     private patchCoinInfo;
 }
 export {};

package/lib/backend/BackendManager.js

@@ -24,7 +24,10 @@ class BackendManager {
                 postMessage,
                 debug: DataManager_1.DataManager.getSettings('debug'),
                 proxy: DataManager_1.DataManager.getSettings('proxy'),
-                onDisconnected: this.onDisconnected.bind(this),
+                onDisconnected: pendingSubscriptions => {
+                    const reconnectAttempts = pendingSubscriptions ? 0 : undefined;
+                    this.onDisconnect(coinInfo, postMessage, reconnectAttempts);
+                },
             });
             this.setInstance(coinInfo.shortcut, backend);
         }
@@ -35,11 +38,7 @@ class BackendManager {
             return backend;
         }
         catch (error) {
-            this.setInstance(coinInfo.shortcut, undefined);
-            this.setPreferred(coinInfo.shortcut, undefined);
-            if (reconnect) {
-                this.planReconnect(backend.coinInfo, backend.postMessage, reconnect.attempts);
-            }
+            this.onDisconnect(coinInfo, postMessage, reconnect === null || reconnect === void 0 ? void 0 : reconnect.attempts);
             throw error;
         }
     }
@@ -79,15 +78,22 @@ class BackendManager {
         else
             this.preferred[shortcut] = url;
     }
-    planReconnect(coinInfo, postMessage, attempts) {
+    onDisconnect(coinInfo, postMessage, reconnectAttempt) {
         var _a;
-        const timeout = Math.min(2500 * attempts, 20000);
+        this.setInstance(coinInfo.shortcut, undefined);
+        if (reconnectAttempt === undefined || reconnectAttempt === 4) {
+            this.setPreferred(coinInfo.shortcut, undefined);
+        }
+        if (reconnectAttempt === undefined) {
+            return;
+        }
+        const timeout = Math.min(2500 * reconnectAttempt, 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 };
+        this.reconnect[coinInfo.shortcut] = { attempts: reconnectAttempt + 1, handle };
         postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.RECONNECTING, { coin: coinInfo, time }));
     }
     clearReconnect(shortcut) {
@@ -96,12 +102,6 @@ class BackendManager {
         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;
         const custom = this.custom[coinInfo.shortcut];

package/lib/backend/Blockchain.d.ts

@@ -7,7 +7,7 @@ export type BlockchainOptions = {
     postMessage: (message: CoreEventMessage) => void;
     proxy?: Proxy;
     debug?: boolean;
-    onDisconnected?: (backend: Blockchain, pendingSubscriptions?: boolean) => void;
+    onDisconnected?: (pendingSubscriptions?: boolean) => void;
 };
 export declare class Blockchain {
     link: BlockchainLink;

package/lib/backend/Blockchain.js

@@ -58,7 +58,7 @@ class Blockchain {
             error: error.message,
             code: error.code,
         }));
-        (_a = this.onDisconnected) === null || _a === void 0 ? void 0 : _a.call(this, this, !!pendingSubscriptions);
+        (_a = this.onDisconnected) === null || _a === void 0 ? void 0 : _a.call(this, !!pendingSubscriptions);
     }
     async initLink() {
         let info;

package/lib/core/index.js

@@ -114,6 +114,7 @@ const initDevice = async (method) => {
     let showDeviceSelection = isWebUsb;
     const isUsingPopup = DataManager_1.DataManager.getSettings('popup');
     const origin = DataManager_1.DataManager.getSettings('origin');
+    const useCoreInPopup = DataManager_1.DataManager.getSettings('useCoreInPopup');
     const { preferredDevice } = connect_common_1.storage.load().origin[origin] || {};
     const preferredDeviceInList = preferredDevice && _deviceList.getDevice(preferredDevice.path);
     if (preferredDevice && !preferredDeviceInList) {
@@ -129,9 +130,10 @@ const initDevice = async (method) => {
     }
     else {
         const devices = _deviceList.asArray();
-        if (devices.length === 1 && !isWebUsb) {
+        if (devices.length === 1 && (!isWebUsb || !isUsingPopup)) {
             device = _deviceList.getDevice(devices[0].path);
-            showDeviceSelection = !!(device === null || device === void 0 ? void 0 : device.unreadableError) || device.isUnacquired();
+            showDeviceSelection =
+                !!(device === null || device === void 0 ? void 0 : device.unreadableError) || device.isUnacquired() || !!useCoreInPopup;
         }
         else {
             showDeviceSelection = true;
@@ -159,11 +161,11 @@ const initDevice = async (method) => {
             if (uiPromise) {
                 const { payload } = await uiPromise.promise;
                 if (payload.remember) {
-                    const { path, state } = payload.device;
+                    const { label, path, state } = payload.device;
                     connect_common_1.storage.save(store => {
                         store.origin[origin] = {
                             ...store.origin[origin],
-                            preferredDevice: { path, state },
+                            preferredDevice: { label, path, state },
                         };
                         return store;
                     });
@@ -186,6 +188,8 @@ const onCall = async (message) => {
     const trustedHost = DataManager_1.DataManager.getSettings('trustedHost');
     const isUsingPopup = DataManager_1.DataManager.getSettings('popup');
     const origin = DataManager_1.DataManager.getSettings('origin');
+    const env = DataManager_1.DataManager.getSettings('env');
+    const useCoreInPopup = DataManager_1.DataManager.getSettings('useCoreInPopup');
     const { preferredDevice } = connect_common_1.storage.loadForOrigin(origin) || {};
     if (preferredDevice && !message.payload.device) {
         message.payload.device = preferredDevice;
@@ -294,6 +298,31 @@ const onCall = async (message) => {
     device.on(events_2.DEVICE.PASSPHRASE_ON_DEVICE, () => {
         postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE_ON_DEVICE, { device: device.toMessageObject() }));
     });
+    device.on(events_2.DEVICE.SAVE_STATE, (state) => {
+        connect_common_1.storage.saveForOrigin(store => {
+            if (useCoreInPopup && env === 'webextension') {
+                return {
+                    ...store,
+                    preferredDevice: store.preferredDevice
+                        ? {
+                            ...store.preferredDevice,
+                            internalState: state,
+                            internalStateExpiration: Date.now() + 1000 * 60 * 15,
+                        }
+                        : undefined,
+                };
+            }
+            return store;
+        }, origin);
+    });
+    if (!device.getInternalState() && useCoreInPopup && env === 'webextension') {
+        const { preferredDevice } = connect_common_1.storage.loadForOrigin(origin) || {};
+        if ((preferredDevice === null || preferredDevice === void 0 ? void 0 : preferredDevice.internalState) &&
+            (preferredDevice === null || preferredDevice === void 0 ? void 0 : preferredDevice.internalStateExpiration) &&
+            preferredDevice.internalStateExpiration > new Date().getTime()) {
+            device.setInternalState(preferredDevice.internalState);
+        }
+    }
     try {
         let PIN_TRIES = 1;
         const MAX_PIN_TRIES = 3;