@trezor/connect 9.0.0-beta.1

package/lib/device/Device.js

@@ -0,0 +1,527 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = void 0;
+const tslib_1 = require("tslib");
+const events_1 = (0, tslib_1.__importDefault)(require("events"));
+const DeviceCommands_1 = require("./DeviceCommands");
+const constants_1 = require("../constants");
+const events_2 = require("../events");
+const coinInfo_1 = require("../data/coinInfo");
+const firmwareInfo_1 = require("../data/firmwareInfo");
+const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
+const versionUtils_1 = require("../utils/versionUtils");
+const deferred_1 = require("../utils/deferred");
+const debug_1 = require("../utils/debug");
+const _log = (0, debug_1.initLog)('Device');
+const parseRunOptions = (options) => {
+    if (!options)
+        options = {};
+    return options;
+};
+class Device extends events_1.default {
+    constructor(transport, descriptor) {
+        super();
+        this.featuresNeedsReload = false;
+        this.deferredActions = {};
+        this.loaded = false;
+        this.inconsistent = false;
+        this.keepSession = false;
+        this.instance = 0;
+        this.internalState = [];
+        this.externalState = [];
+        this.unavailableCapabilities = {};
+        this.networkTypeState = [];
+        this.transport = transport;
+        this.originalDescriptor = descriptor;
+        this.firstRunPromise = (0, deferred_1.create)();
+    }
+    static fromDescriptor(transport, originalDescriptor) {
+        const descriptor = { ...originalDescriptor, session: null };
+        try {
+            const device = new Device(transport, descriptor);
+            return device;
+        }
+        catch (error) {
+            _log.error('Device.fromDescriptor', error);
+            throw error;
+        }
+    }
+    static createUnacquired(transport, descriptor, unreadableError) {
+        const device = new Device(transport, descriptor);
+        device.unreadableError = unreadableError;
+        return device;
+    }
+    async acquire() {
+        this.deferredActions[events_2.DEVICE.ACQUIRE] = (0, deferred_1.create)();
+        this.deferredActions[events_2.DEVICE.ACQUIRED] = (0, deferred_1.create)();
+        try {
+            const sessionID = await this.transport.acquire({
+                path: this.originalDescriptor.path,
+                previous: this.originalDescriptor.session,
+            }, false);
+            _log.debug('Expected session id:', sessionID);
+            this.activitySessionID = sessionID;
+            this.deferredActions[events_2.DEVICE.ACQUIRED].resolve();
+            delete this.deferredActions[events_2.DEVICE.ACQUIRED];
+            if (this.commands) {
+                this.commands.dispose();
+            }
+            this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, sessionID);
+            this.deferredActions[events_2.DEVICE.RELEASE] = (0, deferred_1.create)();
+        }
+        catch (error) {
+            this.deferredActions[events_2.DEVICE.ACQUIRED].resolve();
+            delete this.deferredActions[events_2.DEVICE.ACQUIRED];
+            if (this.runPromise) {
+                this.runPromise.reject(error);
+            }
+            else {
+                throw error;
+            }
+            this.runPromise = null;
+        }
+    }
+    async release() {
+        if (this.isUsedHere() && !this.keepSession && this.activitySessionID) {
+            if (this.commands) {
+                this.commands.dispose();
+                if (this.commands.callPromise) {
+                    try {
+                        await this.commands.callPromise;
+                    }
+                    catch (error) {
+                        this.commands.callPromise = undefined;
+                    }
+                }
+            }
+            try {
+                await this.transport.release(this.activitySessionID, false, false);
+                if (this.deferredActions[events_2.DEVICE.RELEASE])
+                    await this.deferredActions[events_2.DEVICE.RELEASE].promise;
+            }
+            catch (err) {
+            }
+        }
+    }
+    async cleanup() {
+        this.removeAllListeners();
+        this.runPromise = null;
+        await this.release();
+    }
+    run(fn, options) {
+        if (this.runPromise) {
+            _log.warn('Previous call is still running');
+            throw constants_1.ERRORS.TypedError('Device_CallInProgress');
+        }
+        options = parseRunOptions(options);
+        this.runPromise = (0, deferred_1.create)(this._runInner.bind(this, fn, options));
+        return this.runPromise.promise;
+    }
+    async override(error) {
+        if (this.deferredActions[events_2.DEVICE.ACQUIRE]) {
+            await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
+        }
+        if (this.runPromise) {
+            this.runPromise.reject(error);
+            this.runPromise = null;
+        }
+        if (!this.keepSession && this.deferredActions[events_2.DEVICE.RELEASE]) {
+            await this.deferredActions[events_2.DEVICE.RELEASE].promise;
+        }
+    }
+    async interruptionFromUser(error) {
+        _log.debug('interruptionFromUser');
+        if (this.commands) {
+            await this.commands.cancel();
+            this.commands.dispose();
+        }
+        if (this.runPromise) {
+            this.runPromise.reject(error);
+            this.runPromise = null;
+        }
+    }
+    interruptionFromOutside() {
+        _log.debug('interruptionFromOutside');
+        if (this.commands) {
+            this.commands.dispose();
+        }
+        if (this.runPromise) {
+            this.runPromise.reject(constants_1.ERRORS.TypedError('Device_UsedElsewhere'));
+            this.runPromise = null;
+        }
+    }
+    async _runInner(fn, options) {
+        if (!this.isUsedHere() || this.commands.disposed || !this.getExternalState()) {
+            await this.acquire();
+            try {
+                if (fn) {
+                    await this.initialize(!!options.useEmptyPassphrase, !!options.useCardanoDerivation);
+                }
+                else {
+                    await Promise.race([
+                        this.getFeatures(),
+                        new Promise((_resolve, reject) => setTimeout(() => reject(new Error('GetFeatures timeout')), 3000)),
+                    ]);
+                }
+            }
+            catch (error) {
+                if (!this.inconsistent && error.message === 'GetFeatures timeout') {
+                    this.inconsistent = true;
+                    return this._runInner(() => Promise.resolve({}), options);
+                }
+                this.inconsistent = true;
+                await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
+                this.runPromise = null;
+                return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}, code: ${error.code}`));
+            }
+        }
+        if (options.keepSession) {
+            this.keepSession = true;
+        }
+        await this.deferredActions[events_2.DEVICE.ACQUIRE].promise;
+        if (fn) {
+            await fn();
+        }
+        if (this.loaded && this.features && !options.skipFinalReload) {
+            await this.getFeatures();
+        }
+        if ((!this.keepSession && typeof options.keepSession !== 'boolean') ||
+            options.keepSession === false) {
+            this.keepSession = false;
+            await this.release();
+        }
+        if (this.runPromise) {
+            this.runPromise.resolve();
+        }
+        this.runPromise = null;
+        if (!this.loaded) {
+            this.loaded = true;
+            this.firstRunPromise.resolve(true);
+        }
+    }
+    getCommands() {
+        return this.commands;
+    }
+    setInstance(instance = 0) {
+        if (this.instance !== instance) {
+            if (this.keepSession) {
+                this.activitySessionID = null;
+                this.keepSession = false;
+            }
+            if (this.isT1() && this.useLegacyPassphrase()) {
+                this.setInternalState(undefined);
+            }
+        }
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    setInternalState(state) {
+        if (typeof state !== 'string') {
+            delete this.internalState[this.instance];
+        }
+        else {
+            this.internalState[this.instance] = state;
+        }
+    }
+    getInternalState() {
+        return this.internalState[this.instance];
+    }
+    setExternalState(state) {
+        if (typeof state !== 'string') {
+            delete this.internalState[this.instance];
+            delete this.externalState[this.instance];
+        }
+        else {
+            this.externalState[this.instance] = state;
+        }
+    }
+    getExternalState() {
+        return this.externalState[this.instance];
+    }
+    async validateState(networkType) {
+        if (!this.features)
+            return;
+        const altMode = this._altModeChange(networkType);
+        const expectedState = altMode ? undefined : this.getExternalState();
+        const state = await this.commands.getDeviceState(networkType);
+        const uniqueState = `${state}@${this.features.device_id || 'device_id'}:${this.instance}`;
+        if (!this.useLegacyPassphrase() && this.features.session_id) {
+            this.setInternalState(this.features.session_id);
+        }
+        if (expectedState && expectedState !== uniqueState) {
+            return uniqueState;
+        }
+        if (!expectedState) {
+            this.setExternalState(uniqueState);
+        }
+    }
+    useLegacyPassphrase() {
+        return !this.atLeast(['1.9.0', '2.3.0']);
+    }
+    async initialize(useEmptyPassphrase, useCardanoDerivation) {
+        let payload;
+        if (this.features) {
+            const legacy = this.useLegacyPassphrase();
+            const internalState = this.getInternalState();
+            payload = {};
+            payload.derive_cardano = useCardanoDerivation;
+            if (!legacy && internalState) {
+                payload.session_id = internalState;
+            }
+            if (legacy && !this.isT1()) {
+                payload.state = internalState;
+                if (useEmptyPassphrase) {
+                    payload._skip_passphrase = useEmptyPassphrase;
+                    payload.state = null;
+                }
+            }
+        }
+        const { message } = await this.commands.typedCall('Initialize', 'Features', payload);
+        this._updateFeatures(message);
+    }
+    async getFeatures() {
+        const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
+        this._updateFeatures(message);
+    }
+    _updateFeatures(feat) {
+        const capabilities = (0, deviceFeaturesUtils_1.parseCapabilities)(feat);
+        feat.capabilities = capabilities;
+        const version = [feat.major_version, feat.minor_version, feat.patch_version];
+        const capabilitiesDidChange = this.features &&
+            this.features.capabilities &&
+            this.features.capabilities.join('') !== capabilities.join('');
+        if ((0, versionUtils_1.versionCompare)(version, this.getVersion()) !== 0 || capabilitiesDidChange) {
+            this.unavailableCapabilities = (0, deviceFeaturesUtils_1.getUnavailableCapabilities)(feat, (0, coinInfo_1.getAllNetworks)());
+            this.firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat);
+            this.firmwareRelease = (0, firmwareInfo_1.getRelease)(feat);
+        }
+        if (this.features && this.features.session_id && !feat.session_id) {
+            feat.session_id = this.features.session_id;
+        }
+        feat.unlocked = feat.unlocked || true;
+        const revision = (0, deviceFeaturesUtils_1.parseRevision)(feat);
+        feat.revision = revision;
+        this.features = feat;
+        this.featuresNeedsReload = false;
+    }
+    isUnacquired() {
+        return this.features === undefined;
+    }
+    async updateDescriptor(upcomingDescriptor) {
+        const originalSession = this.originalDescriptor.session;
+        const upcomingSession = upcomingDescriptor.session;
+        _log.debug('updateDescriptor', 'currentSession', originalSession, 'upcoming', upcomingSession, 'lastUsedID', this.activitySessionID);
+        if (!originalSession && !upcomingSession && !this.activitySessionID) {
+            return;
+        }
+        if (this.deferredActions[events_2.DEVICE.ACQUIRED]) {
+            await this.deferredActions[events_2.DEVICE.ACQUIRED].promise;
+        }
+        if (!upcomingSession) {
+            if (this.listeners(events_2.DEVICE.ACQUIRED).length > 0) {
+                this.emit(events_2.DEVICE.ACQUIRED);
+            }
+        }
+        const methodStillRunning = this.commands && !this.commands.disposed;
+        if (!upcomingSession && !methodStillRunning) {
+            if (originalSession === this.activitySessionID) {
+                _log.debug('Session released by this app');
+                if (this.deferredActions[events_2.DEVICE.RELEASE]) {
+                    this.deferredActions[events_2.DEVICE.RELEASE].resolve();
+                    delete this.deferredActions[events_2.DEVICE.RELEASE];
+                }
+                this.activitySessionID = null;
+            }
+            else {
+                _log.debug('Session released by other app');
+                this.featuresNeedsReload = true;
+            }
+            this.keepSession = false;
+        }
+        else if (upcomingSession === this.activitySessionID) {
+            _log.debug('Session acquired by this app');
+            if (this.deferredActions[events_2.DEVICE.ACQUIRE]) {
+                this.deferredActions[events_2.DEVICE.ACQUIRE].resolve();
+            }
+        }
+        else {
+            _log.debug('Session acquired by other app');
+            this.interruptionFromOutside();
+        }
+        this.originalDescriptor = upcomingDescriptor;
+    }
+    disconnect() {
+        _log.debug('Disconnect cleanup');
+        if (this.deferredActions[events_2.DEVICE.RELEASE]) {
+            this.deferredActions[events_2.DEVICE.RELEASE].resolve();
+            delete this.deferredActions[events_2.DEVICE.RELEASE];
+        }
+        this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
+        this.runPromise = null;
+    }
+    isBootloader() {
+        return this.features && !!this.features.bootloader_mode;
+    }
+    isInitialized() {
+        return this.features && !!this.features.initialized;
+    }
+    isSeedless() {
+        return this.features && !!this.features.no_backup;
+    }
+    isInconsistent() {
+        return this.inconsistent;
+    }
+    getVersion() {
+        if (!this.features)
+            return [];
+        return [
+            this.features.major_version,
+            this.features.minor_version,
+            this.features.patch_version,
+        ];
+    }
+    atLeast(versions) {
+        if (!this.features)
+            return false;
+        const modelVersion = typeof versions === 'string' ? versions : versions[this.features.major_version - 1];
+        return (0, versionUtils_1.versionCompare)(this.getVersion(), modelVersion) >= 0;
+    }
+    isUsed() {
+        return typeof this.originalDescriptor.session === 'string';
+    }
+    isUsedHere() {
+        return this.isUsed() && this.originalDescriptor.session === this.activitySessionID;
+    }
+    isUsedElsewhere() {
+        return this.isUsed() && !this.isUsedHere();
+    }
+    isRunning() {
+        return !!this.runPromise;
+    }
+    isLoaded() {
+        return this.loaded;
+    }
+    waitForFirstRun() {
+        return this.firstRunPromise.promise;
+    }
+    getDevicePath() {
+        return this.originalDescriptor.path;
+    }
+    needAuthentication() {
+        if (this.isUnacquired() || this.isUsedElsewhere() || this.featuresNeedsReload)
+            return true;
+        if (this.features.bootloader_mode || !this.features.initialized)
+            return true;
+        const pin = this.features.pin_protection ? !!this.features.unlocked : true;
+        const pass = this.features.passphrase_protection ? this.features.passphrase_cached : true;
+        return pin && pass;
+    }
+    isT1() {
+        return this.features ? this.features.major_version === 1 : false;
+    }
+    hasUnexpectedMode(allow, require) {
+        if (this.features) {
+            if (this.isBootloader() && !allow.includes(events_2.UI.BOOTLOADER)) {
+                return events_2.UI.BOOTLOADER;
+            }
+            if (!this.isInitialized() && !allow.includes(events_2.UI.INITIALIZE)) {
+                return events_2.UI.INITIALIZE;
+            }
+            if (this.isSeedless() && !allow.includes(events_2.UI.SEEDLESS)) {
+                return events_2.UI.SEEDLESS;
+            }
+            if (!this.isBootloader() && require.includes(events_2.UI.BOOTLOADER)) {
+                return events_2.UI.NOT_IN_BOOTLOADER;
+            }
+        }
+        return null;
+    }
+    dispose() {
+        this.removeAllListeners();
+        if (this.isUsedHere() && this.activitySessionID) {
+            try {
+                if (this.commands) {
+                    this.commands.cancel();
+                }
+                this.transport.release(this.activitySessionID, true, false);
+            }
+            catch (err) {
+            }
+        }
+    }
+    getMode() {
+        if (this.features.bootloader_mode)
+            return 'bootloader';
+        if (!this.features.initialized)
+            return 'initialize';
+        if (this.features.no_backup)
+            return 'seedless';
+        return 'normal';
+    }
+    toMessageObject() {
+        if (this.unreadableError) {
+            return {
+                type: 'unreadable',
+                path: this.originalDescriptor.path,
+                error: this.unreadableError,
+                label: 'Unreadable device',
+            };
+        }
+        if (this.isUnacquired()) {
+            return {
+                type: 'unacquired',
+                path: this.originalDescriptor.path,
+                label: 'Unacquired device',
+            };
+        }
+        const defaultLabel = 'My Trezor';
+        const label = this.features.label === '' || !this.features.label ? defaultLabel : this.features.label;
+        let status = this.isUsedElsewhere() ? 'occupied' : 'available';
+        if (this.featuresNeedsReload)
+            status = 'used';
+        return {
+            type: 'acquired',
+            id: this.features.device_id || null,
+            path: this.originalDescriptor.path,
+            label,
+            state: this.getExternalState(),
+            status,
+            mode: this.getMode(),
+            firmware: this.firmwareStatus,
+            firmwareRelease: this.firmwareRelease,
+            features: this.features,
+            unavailableCapabilities: this.unavailableCapabilities,
+        };
+    }
+    _getNetworkTypeState() {
+        return this.networkTypeState[this.instance];
+    }
+    _setNetworkTypeState(networkType) {
+        if (typeof networkType !== 'string') {
+            delete this.networkTypeState[this.instance];
+        }
+        else {
+            this.networkTypeState[this.instance] = networkType;
+        }
+    }
+    _altModeChange(networkType) {
+        const prevAltMode = this._isAltModeNetworkType(this._getNetworkTypeState());
+        const nextAltMode = this._isAltModeNetworkType(networkType);
+        this._setNetworkTypeState(networkType);
+        return prevAltMode !== nextAltMode;
+    }
+    _isAltModeNetworkType(networkType) {
+        return networkType ? ['cardano'].includes(networkType) : false;
+    }
+    async legacyForceRelease() {
+        if (this.isUsedHere()) {
+            await this.acquire();
+            await this.getFeatures();
+            await this.release();
+        }
+    }
+}
+exports.Device = Device;
+//# sourceMappingURL=Device.js.map

package/lib/device/DeviceCommands.d.ts

@@ -0,0 +1,63 @@
+import { Transport, Messages } from '@trezor/transport';
+import type { Device } from './Device';
+import type { CoinInfo, BitcoinNetworkInfo } from '../types';
+import type { HDNodeResponse } from '../types/api/getPublicKey';
+declare type MessageType = Messages.MessageType;
+declare type MessageKey = keyof MessageType;
+export declare type TypedResponseMessage<T extends MessageKey> = {
+    type: T;
+    message: MessageType[T];
+};
+declare type TypedCallResponseMap = {
+    [K in keyof MessageType]: TypedResponseMessage<K>;
+};
+export declare type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
+export declare type PassphrasePromptResponse = {
+    passphrase?: string;
+    passphraseOnDevice?: boolean;
+    cache?: boolean;
+};
+export declare class DeviceCommands {
+    device: Device;
+    transport: Transport;
+    sessionId: string;
+    disposed: boolean;
+    callPromise?: Promise<DefaultMessageResponse>;
+    _cancelableRequest?: (error?: any) => void;
+    constructor(device: Device, transport: Transport, sessionId: string);
+    dispose(): void;
+    isDisposed(): boolean;
+    getPublicKey(address_n: number[], coin_name?: string, script_type?: Messages.InputScriptType, show_display?: boolean): Promise<Messages.PublicKey>;
+    getHDNode(path: number[], coinInfo?: BitcoinNetworkInfo, validation?: boolean, showOnTrezor?: boolean): Promise<HDNodeResponse>;
+    getBitcoinHDNode(path: number[], coinInfo?: BitcoinNetworkInfo, validation?: boolean): Promise<HDNodeResponse>;
+    getAddress({ address_n, show_display, multisig, script_type }: Messages.GetAddress, coinInfo: BitcoinNetworkInfo): Promise<{
+        path: number[];
+        serializedPath: string;
+        address: string;
+    }>;
+    ethereumGetAddress({ address_n, show_display }: Messages.EthereumGetAddress): Promise<{
+        path: number[];
+        serializedPath: string;
+        address: string;
+    }>;
+    ethereumGetPublicKey({ address_n, show_display, }: Messages.EthereumGetPublicKey): Promise<HDNodeResponse>;
+    getDeviceState(networkType?: string): Promise<string>;
+    call(type: MessageKey, msg?: DefaultMessageResponse['message']): Promise<DefaultMessageResponse>;
+    typedCall<T extends MessageKey, R extends MessageKey[]>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedCallResponseMap[R[number]]>;
+    typedCall<T extends MessageKey, R extends MessageKey>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedResponseMessage<R>>;
+    _commonCall(type: MessageKey, msg?: DefaultMessageResponse['message']): Promise<DefaultMessageResponse>;
+    _filterCommonTypes(res: DefaultMessageResponse): Promise<DefaultMessageResponse>;
+    _getAddressForNetworkType(networkType?: string): Promise<string>;
+    _promptPin(type?: Messages.PinMatrixRequestType): Promise<string>;
+    _promptPassphrase(): Promise<PassphrasePromptResponse>;
+    _promptWord(type: Messages.WordRequestType): Promise<string>;
+    getAccountDescriptor(coinInfo: CoinInfo, indexOrPath: number | number[], derivationType?: Messages.CardanoDerivationType): Promise<{
+        descriptor: string;
+        legacyXpub?: string;
+        address_n: number[];
+    }>;
+    cancel(): Promise<void>;
+}
+export declare type TypedCall = DeviceCommands['typedCall'];
+export {};
+//# sourceMappingURL=DeviceCommands.d.ts.map