@trezor/connect 9.0.0-beta.1

package/lib/device/DescriptorStream.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import type { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
+export declare type DeviceDescriptorDiff = {
+    didUpdate: boolean;
+    connected: DeviceDescriptor[];
+    disconnected: DeviceDescriptor[];
+    changedSessions: DeviceDescriptor[];
+    changedDebugSessions: DeviceDescriptor[];
+    acquired: DeviceDescriptor[];
+    debugAcquired: DeviceDescriptor[];
+    released: DeviceDescriptor[];
+    debugReleased: DeviceDescriptor[];
+    descriptors: DeviceDescriptor[];
+};
+export declare class DescriptorStream extends EventEmitter {
+    transport: Transport;
+    listening: boolean;
+    listenTimestamp: number;
+    current: DeviceDescriptor[] | null;
+    upcoming: DeviceDescriptor[];
+    constructor(transport: Transport);
+    listen(): Promise<void>;
+    enumerate(): Promise<void>;
+    stop(): void;
+    _reportChanges(): void;
+}
+//# sourceMappingURL=DescriptorStream.d.ts.map

package/lib/device/DescriptorStream.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescriptorStream = void 0;
+const tslib_1 = require("tslib");
+const events_1 = (0, tslib_1.__importDefault)(require("events"));
+const transport_1 = require("../events/transport");
+const device_1 = require("../events/device");
+const debug_1 = require("../utils/debug");
+const DataManager_1 = require("../data/DataManager");
+const promiseUtils_1 = require("../utils/promiseUtils");
+const logger = (0, debug_1.initLog)('DescriptorStream');
+const getDiff = (current, descriptors) => {
+    const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
+    const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
+    const changedSessions = descriptors.filter(d => {
+        const currentDescriptor = current.find(x => x.path === d.path);
+        if (currentDescriptor) {
+            return currentDescriptor.session !== d.session;
+        }
+        return false;
+    });
+    const acquired = changedSessions.filter(d => typeof d.session === 'string');
+    const released = changedSessions.filter(d => typeof d.session !== 'string');
+    const changedDebugSessions = descriptors.filter(d => {
+        const currentDescriptor = current.find(x => x.path === d.path);
+        if (currentDescriptor) {
+            return currentDescriptor.debugSession !== d.debugSession;
+        }
+        return false;
+    });
+    const debugAcquired = changedSessions.filter(d => typeof d.debugSession === 'string');
+    const debugReleased = changedSessions.filter(d => typeof d.debugSession !== 'string');
+    const didUpdate = connected.length +
+        disconnected.length +
+        changedSessions.length +
+        changedDebugSessions.length >
+        0;
+    return {
+        connected,
+        disconnected,
+        changedSessions,
+        acquired,
+        released,
+        changedDebugSessions,
+        debugAcquired,
+        debugReleased,
+        didUpdate,
+        descriptors,
+    };
+};
+class DescriptorStream extends events_1.default {
+    constructor(transport) {
+        super();
+        this.listening = false;
+        this.listenTimestamp = 0;
+        this.current = null;
+        this.upcoming = [];
+        this.transport = transport;
+    }
+    async listen() {
+        const waitForEvent = this.current !== null;
+        const current = this.current || [];
+        this.listening = true;
+        let descriptors;
+        try {
+            logger.debug('Start listening', current);
+            this.listenTimestamp = new Date().getTime();
+            descriptors = waitForEvent
+                ? await this.transport.listen(current)
+                : await this.transport.enumerate();
+            if (this.listening && !waitForEvent) {
+                if (descriptors.length > 0 && DataManager_1.DataManager.getSettings('pendingTransportEvent')) {
+                    this.emit(transport_1.TRANSPORT.START_PENDING, descriptors.length);
+                }
+                else {
+                    this.emit(transport_1.TRANSPORT.START);
+                }
+            }
+            if (!this.listening)
+                return;
+            this.upcoming = descriptors;
+            logger.debug('Listen result', descriptors);
+            this._reportChanges();
+            if (this.listening)
+                this.listen();
+        }
+        catch (error) {
+            const time = new Date().getTime() - this.listenTimestamp;
+            logger.debug('Listen error', 'timestamp', time, typeof error);
+            if (time > 1100) {
+                await (0, promiseUtils_1.resolveAfter)(1000, null);
+                if (this.listening)
+                    this.listen();
+            }
+            else {
+                logger.warn('Transport error');
+                this.emit(transport_1.TRANSPORT.ERROR, error);
+            }
+        }
+    }
+    async enumerate() {
+        if (!this.listening)
+            return;
+        try {
+            this.upcoming = await this.transport.enumerate();
+            this._reportChanges();
+        }
+        catch (error) {
+        }
+    }
+    stop() {
+        this.listening = false;
+        this.removeAllListeners();
+    }
+    _reportChanges() {
+        const diff = getDiff(this.current || [], this.upcoming);
+        this.current = this.upcoming;
+        if (diff.didUpdate && this.listening) {
+            diff.connected.forEach(d => {
+                this.emit(device_1.DEVICE.CONNECT, d);
+            });
+            diff.disconnected.forEach(d => {
+                this.emit(device_1.DEVICE.DISCONNECT, d);
+            });
+            diff.acquired.forEach(d => {
+                this.emit(device_1.DEVICE.ACQUIRED, d);
+            });
+            diff.released.forEach(d => {
+                this.emit(device_1.DEVICE.RELEASED, d);
+            });
+            diff.changedSessions.forEach(d => {
+                this.emit(device_1.DEVICE.CHANGED, d);
+            });
+            this.emit(transport_1.TRANSPORT.UPDATE, diff);
+        }
+    }
+}
+exports.DescriptorStream = DescriptorStream;
+//# sourceMappingURL=DescriptorStream.js.map

package/lib/device/Device.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { DeviceCommands } from './DeviceCommands';
+import { PROTO, NETWORK } from '../constants';
+import { DEVICE, DeviceButtonRequestPayload } from '../events';
+import { Deferred } from '../utils/deferred';
+import type { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
+import type { Device as DeviceTyped, DeviceFirmwareStatus, Features, ReleaseInfo, UnavailableCapabilities } from '../types';
+export declare type RunOptions = {
+    skipFinalReload?: boolean;
+    waiting?: boolean;
+    onlyOneActivity?: boolean;
+    cancelPopupRequest?: () => any;
+    keepSession?: boolean;
+    useEmptyPassphrase?: boolean;
+    useCardanoDerivation?: boolean;
+};
+export interface DeviceEvents {
+    [DEVICE.PIN]: [Device, PROTO.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
+    [DEVICE.WORD]: [Device, PROTO.WordRequestType, (err: any, word: string) => void];
+    [DEVICE.PASSPHRASE]: [Device, (response: any) => void];
+    [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
+    [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
+    [DEVICE.ACQUIRED]: [];
+}
+export interface Device {
+    on<K extends keyof DeviceEvents>(type: K, listener: (...event: DeviceEvents[K]) => void): this;
+    off<K extends keyof DeviceEvents>(type: K, listener: (...event: DeviceEvents[K]) => void): this;
+    emit<K extends keyof DeviceEvents>(type: K, ...args: DeviceEvents[K]): boolean;
+}
+export declare class Device extends EventEmitter {
+    transport: Transport;
+    originalDescriptor: DeviceDescriptor;
+    unreadableError?: string;
+    firmwareStatus: DeviceFirmwareStatus;
+    firmwareRelease?: ReleaseInfo | null;
+    features: Features;
+    featuresNeedsReload: boolean;
+    deferredActions: {
+        [key: string]: Deferred<void>;
+    };
+    runPromise?: Deferred<void> | null;
+    loaded: boolean;
+    inconsistent: boolean;
+    firstRunPromise: Deferred<boolean>;
+    activitySessionID?: string | null;
+    commands: DeviceCommands;
+    keepSession: boolean;
+    instance: number;
+    internalState: string[];
+    externalState: string[];
+    unavailableCapabilities: UnavailableCapabilities;
+    networkTypeState: NETWORK.NetworkType[];
+    constructor(transport: Transport, descriptor: DeviceDescriptor);
+    static fromDescriptor(transport: Transport, originalDescriptor: DeviceDescriptor): Device;
+    static createUnacquired(transport: Transport, descriptor: DeviceDescriptor, unreadableError?: string): Device;
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    cleanup(): Promise<void>;
+    run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
+    override(error: Error): Promise<void>;
+    interruptionFromUser(error: Error): Promise<void>;
+    interruptionFromOutside(): void;
+    _runInner<X>(fn: (() => Promise<X>) | undefined, options: RunOptions): Promise<void>;
+    getCommands(): DeviceCommands;
+    setInstance(instance?: number): void;
+    getInstance(): number;
+    setInternalState(state?: string): void;
+    getInternalState(): string;
+    setExternalState(state?: string): void;
+    getExternalState(): string;
+    validateState(networkType?: NETWORK.NetworkType): Promise<string | undefined>;
+    useLegacyPassphrase(): boolean;
+    initialize(useEmptyPassphrase: boolean, useCardanoDerivation: boolean): Promise<void>;
+    getFeatures(): Promise<void>;
+    _updateFeatures(feat: Features): void;
+    isUnacquired(): boolean;
+    updateDescriptor(upcomingDescriptor: DeviceDescriptor): Promise<void>;
+    disconnect(): void;
+    isBootloader(): boolean;
+    isInitialized(): boolean;
+    isSeedless(): boolean;
+    isInconsistent(): boolean;
+    getVersion(): number[];
+    atLeast(versions: string[] | string): boolean;
+    isUsed(): boolean;
+    isUsedHere(): boolean;
+    isUsedElsewhere(): boolean;
+    isRunning(): boolean;
+    isLoaded(): boolean;
+    waitForFirstRun(): Promise<boolean>;
+    getDevicePath(): string;
+    needAuthentication(): any;
+    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;
+    dispose(): void;
+    getMode(): "normal" | "bootloader" | "initialize" | "seedless";
+    toMessageObject(): DeviceTyped;
+    _getNetworkTypeState(): "bitcoin" | "ethereum" | "nem" | "eos" | "stellar" | "cardano" | "ripple" | "tezos" | "binance";
+    _setNetworkTypeState(networkType?: NETWORK.NetworkType): void;
+    _altModeChange(networkType?: NETWORK.NetworkType): boolean;
+    _isAltModeNetworkType(networkType?: keyof typeof NETWORK.TYPES): boolean;
+    legacyForceRelease(): Promise<void>;
+}
+//# sourceMappingURL=Device.d.ts.map