@trezor/connect 9.4.2 → 9.4.3-beta.2

package/lib/device/Device.d.ts

@@ -1,11 +1,11 @@
-import { Deferred, TypedEmitter } from '@trezor/utils';
+import { TypedEmitter } from '@trezor/utils';
 import { Session } from '@trezor/transport';
 import { TransportProtocol } from '@trezor/protocol';
+import { type Transport, type Descriptor } from '@trezor/transport';
 import { DeviceCommands } from './DeviceCommands';
-import { PROTO, NETWORK } from '../constants';
+import { PROTO } from '../constants';
 import { DEVICE, DeviceButtonRequestPayload, UiResponsePin, UiResponsePassphrase, UiResponseWord } from '../events';
-import { type Transport, type Descriptor } from '@trezor/transport';
-import { Device as DeviceTyped, DeviceFirmwareStatus, DeviceState, Features, ReleaseInfo, UnavailableCapabilities, FirmwareType, VersionArray, KnownDevice } from '../types';
+import { Device as DeviceTyped, DeviceFirmwareStatus, DeviceState, ReleaseInfo, UnavailableCapabilities, FirmwareType, VersionArray, FirmwareHashCheckResult, DeviceUniquePath } from '../types';
 import { IStateStorage } from './StateStorage';
 import type { PromptCallback } from './prompts';
 export type RunOptions = {
@@ -24,50 +24,155 @@ export interface DeviceEvents {
     [DEVICE.PASSPHRASE]: (device: Device, callback: PromptCallback<UiResponsePassphrase['payload']>) => void;
     [DEVICE.PASSPHRASE_ON_DEVICE]: () => void;
     [DEVICE.BUTTON]: (device: Device, payload: DeviceButtonRequestPayload) => void;
-    [DEVICE.ACQUIRED]: () => void;
 }
-export declare class Device extends TypedEmitter<DeviceEvents> {
+type DeviceLifecycle = typeof DEVICE.CONNECT | typeof DEVICE.CONNECT_UNACQUIRED | typeof DEVICE.DISCONNECT | typeof DEVICE.CHANGED;
+type DeviceLifecycleListener = (lifecycle: DeviceLifecycle) => void;
+type DeviceParams = {
+    id: DeviceUniquePath;
     transport: Transport;
-    protocol: TransportProtocol;
-    originalDescriptor: Descriptor;
-    unreadableError?: string;
-    firmwareStatus: DeviceFirmwareStatus;
-    firmwareRelease?: ReleaseInfo | null;
-    features: Features;
-    featuresNeedsReload: boolean;
+    descriptor: Descriptor;
+    listener: DeviceLifecycleListener;
+};
+export declare class Device extends TypedEmitter<DeviceEvents> {
+    readonly transport: Transport;
+    readonly protocol: TransportProtocol;
+    private readonly transportPath;
+    private readonly transportSessionOwner;
+    private readonly transportDescriptorType;
+    private session;
+    private lastAcquiredHere;
+    private unreadableError?;
+    private _firmwareStatus;
+    get firmwareStatus(): DeviceFirmwareStatus;
+    private _firmwareRelease?;
+    get firmwareRelease(): ReleaseInfo | null | undefined;
+    private _features;
+    get features(): {
+        _passphrase_cached?: boolean | undefined;
+        busy?: boolean | undefined;
+        homescreen_format?: "Toif" | "Jpeg" | "ToiG" | undefined;
+        hide_passphrase_from_host?: boolean | undefined;
+        unit_color?: number | undefined;
+        unit_btconly?: boolean | undefined;
+        homescreen_width?: number | undefined;
+        homescreen_height?: number | undefined;
+        bootloader_locked?: boolean | undefined;
+        language_version_matches?: boolean | undefined;
+        unit_packaging?: number | undefined;
+        haptic_feedback?: boolean | undefined;
+        recovery_type?: "NormalRecovery" | "DryRun" | "UnlockRepeatedBackup" | undefined;
+        optiga_sec?: number | undefined;
+        vendor: string;
+        major_version: number;
+        minor_version: number;
+        patch_version: number;
+        bootloader_mode: boolean | null;
+        device_id: string | null;
+        pin_protection: boolean | null;
+        passphrase_protection: boolean | null;
+        language: string | null;
+        label: string | null;
+        initialized: boolean | null;
+        revision: string | null;
+        bootloader_hash: string | null;
+        imported: boolean | null;
+        unlocked: boolean | null;
+        firmware_present: boolean | null;
+        backup_availability: "NotAvailable" | "Required" | "Available" | null;
+        flags: number | null;
+        model: string;
+        fw_major: number | null;
+        fw_minor: number | null;
+        fw_patch: number | null;
+        fw_vendor: string | null;
+        unfinished_backup: boolean | null;
+        no_backup: boolean | null;
+        recovery_status: "Nothing" | "Recovery" | "Backup" | null;
+        capabilities: ("Capability_Bitcoin" | "Capability_Bitcoin_like" | "Capability_Binance" | "Capability_Cardano" | "Capability_Crypto" | "Capability_EOS" | "Capability_Ethereum" | "Capability_Lisk" | "Capability_Monero" | "Capability_NEM" | "Capability_Ripple" | "Capability_Stellar" | "Capability_Tezos" | "Capability_U2F" | "Capability_Shamir" | "Capability_ShamirGroups" | "Capability_PassphraseEntry" | "Capability_Solana" | "Capability_Translations" | "Capability_Brightness" | "Capability_Haptic")[];
+        backup_type: "Bip39" | "Slip39_Basic" | "Slip39_Advanced" | "Slip39_Single_Extendable" | "Slip39_Basic_Extendable" | "Slip39_Advanced_Extendable" | null;
+        sd_card_present: boolean | null;
+        sd_protection: boolean | null;
+        wipe_code_protection: boolean | null;
+        session_id: string | null;
+        passphrase_always_on_device: boolean | null;
+        safety_checks: "Strict" | "PromptAlways" | "PromptTemporarily" | null;
+        auto_lock_delay_ms: number | null;
+        display_rotation: number | null;
+        experimental_features: boolean | null;
+        internal_model: PROTO.DeviceModelInternal;
+    };
+    private _featuresNeedsReload;
     private acquirePromise?;
     private releasePromise?;
     private runPromise?;
-    transportSession?: Session | null;
-    keepTransportSession: boolean;
+    private keepTransportSession;
     commands?: DeviceCommands;
     private cancelableAction?;
-    loaded: boolean;
-    inconsistent: boolean;
-    firstRunPromise: Deferred<boolean>;
-    instance: number;
+    private loaded;
+    private inconsistent;
+    private firstRunPromise;
+    private instance;
     private state;
     private stateStorage?;
-    unavailableCapabilities: UnavailableCapabilities;
-    networkTypeState: NETWORK.NetworkType[];
-    firmwareType?: FirmwareType;
-    name: string;
-    color?: string;
-    availableTranslations: string[];
-    authenticityChecks: NonNullable<KnownDevice['authenticityChecks']>;
-    private useCardanoDerivation;
-    constructor(transport: Transport, descriptor: Descriptor);
-    static fromDescriptor(transport: Transport, originalDescriptor: Descriptor): Device;
-    static createUnacquired(transport: Transport, descriptor: Descriptor, unreadableError?: string): Device;
-    acquire(): Promise<void>;
-    release(): Promise<void>;
+    private _unavailableCapabilities;
+    get unavailableCapabilities(): Readonly<UnavailableCapabilities>;
+    private _firmwareType?;
+    get firmwareType(): FirmwareType | undefined;
+    private name;
+    private color?;
+    private availableTranslations;
+    private authenticityChecks;
+    private readonly uniquePath;
+    private readonly emitLifecycle;
+    private sessionDfd?;
+    constructor({ id, transport, descriptor, listener }: DeviceParams);
+    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" | "descriptor not found">;
+    release(): Promise<{
+        success: false;
+        error: "session not found";
+    } | {
+        success: false;
+        error: "Network request failed";
+    } | {
+        success: false;
+        error: "Wrong result type.";
+    } | {
+        success: false;
+        error: "device disconnected during action";
+    } | {
+        success: false;
+        error: "unexpected error";
+    } | {
+        success: false;
+        error: "Aborted by timeout";
+    } | {
+        success: false;
+        error: "Aborted by signal";
+    } | {
+        success: false;
+        error: "This transport can not be used in this environment";
+    } | {
+        success: false;
+        error: "device not found";
+    } | {
+        success: false;
+        error: "Unable to open device";
+    } | {
+        success: false;
+        error: "wrong previous session";
+    } | import("@trezor/transport/lib/types").Success<null> | undefined>;
+    releaseTransportSession(): void;
     cleanup(): Promise<void>;
+    handshake(delay?: number): Promise<void>;
+    updateDescriptor(descriptor: Descriptor): Promise<void>;
     run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
     override(error: Error): Promise<void>;
     setCancelableAction(callback: NonNullable<typeof this.cancelableAction>): void;
     clearCancelableAction(): void;
     interruptionFromUser(error: Error): Promise<void>;
-    interruptionFromOutside(): void;
+    usedElsewhere(): void;
     _runInner<X>(fn: (() => Promise<X>) | undefined, options: RunOptions): Promise<void>;
     getCommands(): DeviceCommands;
     setInstance(instance?: number): void;
@@ -78,6 +183,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     initialize(useCardanoDerivation: boolean): Promise<void>;
     initStorage(storage: IStateStorage): void;
     getFeatures(): Promise<void>;
+    checkFirmwareHash(): Promise<FirmwareHashCheckResult | null>;
     checkFirmwareRevision(): Promise<void>;
     changeLanguage({ language, binary, }: {
         language?: undefined;
@@ -91,6 +197,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private _uploadTranslationData;
     private _updateFeatures;
     isUnacquired(): boolean;
+    isUnreadable(): boolean;
     disconnect(): Promise<void>;
     isBootloader(): boolean;
     isInitialized(): boolean;
@@ -104,10 +211,10 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     isRunning(): boolean;
     isLoaded(): boolean;
     waitForFirstRun(): Promise<boolean>;
-    getDevicePath(): import("@trezor/transport/lib/types").PathPublic;
+    getLocalSession(): Session | null;
+    getUniquePath(): DeviceUniquePath;
     isT1(): boolean;
     hasUnexpectedMode(allow: string[], require: string[]): "ui-device_bootloader_mode" | "ui-device_not_in_bootloader_mode" | "ui-device_not_initialized" | "ui-device_seedless" | null;
-    updateDescriptor(descriptor: Descriptor): void;
     dispose(): Promise<{
         success: false;
         error: "session not found";
@@ -141,8 +248,9 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     } | {
         success: false;
         error: "wrong previous session";
-    } | import("@trezor/transport/lib/types").Success<void> | undefined>;
+    } | import("@trezor/transport/lib/types").Success<null> | undefined>;
     getMode(): "normal" | "bootloader" | "initialize" | "seedless";
     toMessageObject(): DeviceTyped;
 }
+export {};
 //# sourceMappingURL=Device.d.ts.map