@trezor/connect 9.6.3 → 9.6.4-beta.1

package/lib/device/Device.d.ts

@@ -1,5 +1,5 @@
 import { FirmwareRelease } from '@trezor/device-utils';
-import { TransportProtocol, thp as protocolThp } from '@trezor/protocol';
+import { type DecodedTrezorPushNotification, TransportProtocol, thp as protocolThp } from '@trezor/protocol';
 import { Session } from '@trezor/transport';
 import { type Descriptor, type Transport } from '@trezor/transport';
 import { TypedEmitter } from '@trezor/utils';
@@ -7,7 +7,7 @@ import { PROTO } from '../constants';
 import { TypedCallProvider } from './DeviceCurrentSession';
 import { IStateStorage } from './StateStorage';
 import { DEVICE, DeviceButtonRequestPayload, DeviceThpCredentialsChangedPayload, DeviceThpPairingPayload, DeviceVersionChanged, UiResponsePassphrase, UiResponsePin, UiResponseThpPairingTag, UiResponseWord } from '../events';
-import { DeviceFirmwareStatus, DeviceState, Device as DeviceTyped, DeviceUniquePath, FirmwareHashCheckResult, FirmwareReleaseConfigInfo, FirmwareType, UnavailableCapabilities, VersionArray } from '../types';
+import { DeviceBusyStatus, DeviceFirmwareStatus, DeviceState, Device as DeviceTyped, DeviceUniquePath, FirmwareHashCheckResult, FirmwareReleaseConfigInfo, FirmwareType, UnavailableCapabilities, VersionArray } from '../types';
 type RunOptions = {
     skipFinalReload?: boolean;
     keepSession?: boolean;
@@ -40,6 +40,10 @@ export interface DeviceEvents {
         payload: DeviceButtonRequestPayload;
     };
     [DEVICE.FIRMWARE_VERSION_CHANGED]: DeviceVersionChanged['payload'];
+    [DEVICE.TREZOR_PUSH_NOTIFICATION]: {
+        device: DeviceTyped;
+        payload: DecodedTrezorPushNotification;
+    };
     [DEVICE.THP_PAIRING]: {
         payload: DeviceThpPairingPayload;
         callback: (response: Result<UiResponseThpPairingTag['payload']>) => void;
@@ -51,6 +55,7 @@ interface DeviceLifecycleEvents {
     [DEVICE.CONNECT_UNACQUIRED]: void;
     [DEVICE.CHANGED]: void;
     [DEVICE.DISCONNECT]: void;
+    [DEVICE.TREZOR_PUSH_NOTIFICATION]: DecodedTrezorPushNotification;
 }
 type DeviceParams = {
     id: DeviceUniquePath;
@@ -59,17 +64,14 @@ type DeviceParams = {
 };
 export declare class Device extends TypedEmitter<DeviceEvents> {
     readonly transport: Transport;
-    readonly transportPath: import("@trezor/transport/lib/types").PathPublic;
-    readonly bluetoothProps: {
-        id: string;
-    } | undefined;
     private thp;
-    private readonly possibleHIDdevice;
+    readonly descriptor: Pick<Descriptor, 'apiType' | 'id' | 'type' | 'path'>;
     private sessionAcquired;
     private _protocol;
     get protocol(): TransportProtocol;
     getThpState(): protocolThp.ThpState | undefined;
     private unreadableError?;
+    private channels;
     private _firmwareStatus;
     get firmwareStatus(): DeviceFirmwareStatus;
     private _currentRelease?;
@@ -93,6 +95,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
         recovery_type?: "NormalRecovery" | "DryRun" | "UnlockRepeatedBackup" | undefined;
         optiga_sec?: number | undefined;
         soc?: number | undefined;
+        firmware_corrupted?: boolean | undefined;
         vendor: string;
         major_version: number;
         minor_version: number;
@@ -147,6 +150,8 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     get unavailableCapabilities(): Readonly<UnavailableCapabilities>;
     private _firmwareType?;
     get firmwareType(): FirmwareType | undefined;
+    private get possibleHIDdevice();
+    get possibleT1(): boolean;
     private name;
     private color?;
     private availableTranslations;
@@ -155,11 +160,15 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     readonly lifecycle: TypedEmitter<DeviceLifecycleEvents>;
     private sessionDfd?;
     constructor({ id, transport, descriptor }: DeviceParams);
+    get transportPath(): import("@trezor/transport/lib/types").PathPublic;
     private readonly onTransportStopped;
     private readonly onTransportDeviceEvent;
     private getSessionChangePromise;
     private waitAndCompareSession;
     acquire(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<Session, "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session" | "LIBUSB_ERROR_ACCESS">;
+    reset(): void;
+    setBusy(value?: DeviceBusyStatus): void;
+    subscribe(): void;
     release(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<null, "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "session not found" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session"> | undefined;
     setupThp(): Promise<void>;
     handshake(): Promise<boolean>;
@@ -178,8 +187,8 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
             };
         }>;
         getPublicKey: (params: PROTO.GetPublicKey, unlock?: PROTO.UnlockPath) => Promise<{
-            descriptor?: string | undefined;
             root_fingerprint?: number | undefined;
+            descriptor?: string | undefined;
             node: {
                 private_key?: string | undefined;
                 depth: number;
@@ -224,9 +233,9 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
             descriptorChecksum?: string | undefined;
             depth: number;
             fingerprint: number;
-            chainCode: string;
-            childNum: number;
             xpub: string;
+            childNum: number;
+            chainCode: string;
         }>;
         preauthorize: (throwError: boolean) => Promise<boolean>;
         getAccountDescriptor: (coinInfo: import("../types").CoinInfo, address_n: number[], derivationType?: PROTO.CardanoDerivationType) => Promise<import("./DeviceCommands").AccountDescriptor>;
@@ -258,6 +267,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private _uploadTranslationData;
     private _updateCurrentRelease;
     private _updateFeatures;
+    private _updateFeature;
     prompt<T extends typeof DEVICE.PIN | typeof DEVICE.PASSPHRASE | typeof DEVICE.WORD | typeof DEVICE.THP_PAIRING>(type: T, args: Omit<DeviceEvents[T], 'callback'>): Promise<Parameters<DeviceEvents[T]["callback"]>[0]>;
     isUnacquired(): boolean;
     isUnreadable(): boolean;

package/lib/device/Device.js

@@ -14,18 +14,18 @@ const checkFirmwareHashWithRetries_1 = require("./workflow/checkFirmwareHashWith
 const coinInfo_1 = require("../data/coinInfo");
 const firmwareInfo_1 = require("../data/firmwareInfo");
 const events_1 = require("../events");
+const types_1 = require("../types");
 const handshake_1 = require("./workflow/handshake");
 const assetUtils_1 = require("../utils/assetUtils");
 const debug_1 = require("../utils/debug");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
 const firmwareUtils_1 = require("../utils/firmwareUtils");
+const trezorPushNotification_1 = require("./workflow/trezorPushNotification");
 const _log = (0, debug_1.initLog)('Device');
 class Device extends utils_1.TypedEmitter {
     transport;
-    transportPath;
-    bluetoothProps;
     thp;
-    possibleHIDdevice;
+    descriptor;
     sessionAcquired;
     _protocol;
     get protocol() {
@@ -35,6 +35,10 @@ class Device extends utils_1.TypedEmitter {
         return this.thp;
     }
     unreadableError;
+    channels = {
+        'battery-level': false,
+        'trezor-push-notification': false,
+    };
     _firmwareStatus;
     get firmwareStatus() {
         return this._firmwareStatus;
@@ -70,6 +74,12 @@ class Device extends utils_1.TypedEmitter {
     get firmwareType() {
         return this._firmwareType;
     }
+    get possibleHIDdevice() {
+        return this.descriptor.type === 0 || this.descriptor.type === 2;
+    }
+    get possibleT1() {
+        return (this.descriptor.type ?? 0) <= 2;
+    }
     name = 'Trezor';
     color;
     availableTranslations = {};
@@ -85,12 +95,18 @@ class Device extends utils_1.TypedEmitter {
         this._protocol = protocol_1.v1;
         this.uniquePath = id;
         this.transport = transport;
-        this.transportPath = descriptor.path;
-        this.possibleHIDdevice = [0, 2].includes(descriptor.type);
-        this.bluetoothProps = descriptor.id ? { id: descriptor.id } : undefined;
+        this.descriptor = {
+            id: descriptor.id,
+            apiType: descriptor.apiType,
+            type: descriptor.type,
+            path: descriptor.path,
+        };
         this.sessionAcquired = null;
         transport.on(transport_1.TRANSPORT.STOPPED, this.onTransportStopped);
-        transport.deviceEvents.on(this.transportPath, this.onTransportDeviceEvent);
+        transport.deviceEvents.on(this.descriptor.path, this.onTransportDeviceEvent);
+    }
+    get transportPath() {
+        return this.descriptor.path;
     }
     onTransportStopped = () => this.disconnect();
     onTransportDeviceEvent = (event) => {
@@ -136,9 +152,9 @@ class Device extends utils_1.TypedEmitter {
     }
     acquire() {
         const sessionPromise = this.getSessionChangePromise();
-        const previous = this.transport.getDescriptor(this.transportPath)?.session ?? null;
+        const previous = this.transport.getDescriptor(this.descriptor.path)?.session ?? null;
         this.acquirePromise = this.transport
-            .acquire({ input: { path: this.transportPath, previous } })
+            .acquire({ input: { path: this.descriptor.path, previous } })
             .then(result => this.waitAndCompareSession(result, sessionPromise))
             .then(result => {
             if (result.success) {
@@ -156,13 +172,51 @@ class Device extends utils_1.TypedEmitter {
         });
         return this.acquirePromise;
     }
+    reset() {
+        _log.info(`Resetting Features and ThpState`);
+        this._features = undefined;
+        this._protocol = protocol_1.v1;
+        this.thp?.resetState();
+        this.thp = undefined;
+    }
+    setBusy(value) {
+        this.busy = value;
+    }
+    subscribe() {
+        if (this.descriptor.id && this.descriptor.apiType === 'bluetooth') {
+            this.transport
+                .subscribe({
+                path: this.descriptor.id,
+                channels: ['battery-level', 'trezor-push-notification'],
+            })
+                .then(result => {
+                if (result.success) {
+                    this.channels = result.payload;
+                    this.lifecycle.emit(events_1.DEVICE.CHANGED);
+                }
+                if (this.channels['battery-level']) {
+                    this.transport.on('battery-level', event => {
+                        this._updateFeature('soc', event.data[0]);
+                        this.lifecycle.emit(events_1.DEVICE.CHANGED);
+                    });
+                }
+                if (this.channels['trezor-push-notification']) {
+                    this.transport.on('trezor-push-notification', ({ id, data }) => {
+                        if (id === this.descriptor.id) {
+                            (0, trezorPushNotification_1.trezorPushNotificationHandler)({ device: this, message: data });
+                        }
+                    });
+                }
+            });
+        }
+    }
     release() {
         if (!this.sessionAcquired || this.keepTransportSession || this.releasePromise) {
             return;
         }
         const sessionPromise = this.getSessionChangePromise();
         this.releasePromise = this.transport
-            .release({ session: this.sessionAcquired, path: this.transportPath })
+            .release({ session: this.sessionAcquired, path: this.descriptor.path })
             .then(result => this.waitAndCompareSession(result, sessionPromise))
             .then(result => {
             if (result.success) {
@@ -214,6 +268,7 @@ class Device extends utils_1.TypedEmitter {
                 this.unreadableError = error.message;
             }
         }
+        this.subscribe();
         return true;
     }
     async updateDescriptor(descriptor) {
@@ -293,8 +348,8 @@ class Device extends utils_1.TypedEmitter {
                 await (0, handshake_1.handshakeCancel)({ device: this, logger: _log, signal: abortSignal });
                 if (this.protocol.name === 'v2') {
                     const withInteraction = !!fn;
-                    await (0, thp_1.getThpChannel)(this, withInteraction);
-                    if (this.getThpState()?.isAutoconnectPaired || withInteraction) {
+                    this.busy = await (0, thp_1.getThpChannel)(this, withInteraction);
+                    if (!this.busy) {
                         await this.getFeatures();
                     }
                 }
@@ -304,12 +359,14 @@ class Device extends utils_1.TypedEmitter {
                 else {
                     await this.getFeatures();
                 }
-                this.busy = false;
             }
             catch (error) {
                 _log.warn('Device._runInner error: ', error.message);
                 if (error.code === 'Failure_Busy') {
-                    this.busy = true;
+                    this.busy = 'busy';
+                }
+                if (error.code === 'ThpDeviceLocked') {
+                    this.busy = 'pin-locked';
                 }
                 if (error.code === 'Device_ThpPairingTagInvalid') {
                     return Promise.reject(error);
@@ -546,6 +603,7 @@ class Device extends utils_1.TypedEmitter {
             colors: {},
         };
         this.name = deviceInfo.name;
+        this.busy = undefined;
         if (feat?.unit_color) {
             const deviceUnitColor = feat.unit_color.toString();
             if (deviceUnitColor in deviceInfo.colors) {
@@ -553,6 +611,14 @@ class Device extends utils_1.TypedEmitter {
             }
         }
     }
+    _updateFeature(key, value) {
+        if (this._features) {
+            this._features = {
+                ...this._features,
+                [key]: value,
+            };
+        }
+    }
     prompt(type, args) {
         return new Promise(callback => {
             if (!this.listenerCount(type)) {
@@ -576,7 +642,7 @@ class Device extends utils_1.TypedEmitter {
     disconnect() {
         _log.debug('Disconnect cleanup');
         this.transport.off(transport_1.TRANSPORT.STOPPED, this.onTransportStopped);
-        this.transport.deviceEvents.off(this.transportPath, this.onTransportDeviceEvent);
+        this.transport.deviceEvents.off(this.descriptor.path, this.onTransportDeviceEvent);
         this.removeAllListeners();
         this.sessionDfd?.reject(new Error());
         if (this.sessionAcquired) {
@@ -612,7 +678,7 @@ class Device extends utils_1.TypedEmitter {
         return utils_1.versionUtils.isNewerOrEqual(version, modelVersion);
     }
     isUsed() {
-        return !!this.transport.getDescriptor(this.transportPath)?.session;
+        return !!this.transport.getDescriptor(this.descriptor.path)?.session;
     }
     isUsedHere() {
         return !!this.sessionAcquired;
@@ -649,12 +715,18 @@ class Device extends utils_1.TypedEmitter {
         if (this.wasUsedElsewhere)
             return 'used';
         if (this.busy)
-            return 'busy';
+            return this.busy;
         return 'available';
     }
     toMessageObject() {
-        const { name, uniquePath: path } = this;
-        const base = { path, name };
+        const { name, uniquePath: path, descriptor } = this;
+        const { apiType, id } = descriptor;
+        const base = { path, name, descriptor: { apiType, id } };
+        const bluetoothProps = this.descriptor.id && this.descriptor.apiType === 'bluetooth'
+            ? {
+                id: (0, types_1.asBluetoothDeviceId)(this.descriptor.id),
+            }
+            : undefined;
         if (this.unreadableError) {
             return {
                 ...base,
@@ -665,16 +737,16 @@ class Device extends utils_1.TypedEmitter {
             };
         }
         if (this.isUnacquired()) {
-            const sessionOwner = this.transport.getDescriptor(this.transportPath)?.sessionOwner;
+            const sessionOwner = this.transport.getDescriptor(this.descriptor.path)?.sessionOwner;
             return {
                 ...base,
                 type: 'unacquired',
                 label: 'Unacquired device',
                 name: this.name,
                 transportSessionOwner: this.sessionAcquired ? undefined : sessionOwner,
-                bluetoothProps: this.bluetoothProps,
+                bluetoothProps,
                 thp: this.thp?.serialize(),
-                status: this.busy ? 'busy' : undefined,
+                status: this.busy ? this.busy : undefined,
             };
         }
         const defaultLabel = 'My Trezor';
@@ -696,7 +768,7 @@ class Device extends utils_1.TypedEmitter {
             unavailableCapabilities: this.unavailableCapabilities,
             availableTranslations: this.availableTranslations,
             authenticityChecks: this.authenticityChecks,
-            bluetoothProps: this.bluetoothProps,
+            bluetoothProps,
             thp: this.thp?.serialize(),
         };
     }

package/lib/device/DeviceCommands.d.ts

@@ -1,6 +1,6 @@
 import { MessagesSchema as Messages } from '@trezor/protobuf';
 import type { TypedCallProvider } from '../device/DeviceCurrentSession';
-import type { BitcoinNetworkInfo, CoinInfo } from '../types';
+import type { BitcoinNetworkInfo, CoinInfo } from '../types/coinInfo';
 type TypedCall = Messages.TypedCall;
 export type { TypedCall };
 export type AccountDescriptor = {
@@ -17,8 +17,8 @@ export declare const DeviceCommands: (deviceTypedCall: TypedCallProvider) => {
         };
     }>;
     getPublicKey: (params: Messages.GetPublicKey, unlock?: Messages.UnlockPath) => Promise<{
-        descriptor?: string | undefined;
         root_fingerprint?: number | undefined;
+        descriptor?: string | undefined;
         node: {
             private_key?: string | undefined;
             depth: number;
@@ -63,9 +63,9 @@ export declare const DeviceCommands: (deviceTypedCall: TypedCallProvider) => {
         descriptorChecksum?: string | undefined;
         depth: number;
         fingerprint: number;
-        chainCode: string;
-        childNum: number;
         xpub: string;
+        childNum: number;
+        chainCode: string;
     }>;
     preauthorize: (throwError: boolean) => Promise<boolean>;
     getAccountDescriptor: (coinInfo: CoinInfo, address_n: number[], derivationType?: Messages.CardanoDerivationType) => Promise<AccountDescriptor>;