@trezor/connect 9.0.0-beta.1

package/lib/device/DeviceCommands.js

@@ -0,0 +1,465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceCommands = void 0;
+const tslib_1 = require("tslib");
+const randombytes_1 = (0, tslib_1.__importDefault)(require("randombytes"));
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+const hdnodeUtils = (0, tslib_1.__importStar)(require("../utils/hdnodeUtils"));
+const pathUtils_1 = require("../utils/pathUtils");
+const accountUtils_1 = require("../utils/accountUtils");
+const versionUtils_1 = require("../utils/versionUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const debug_1 = require("../utils/debug");
+const logger = (0, debug_1.initLog)('DeviceCommands');
+const assertType = (res, resType) => {
+    const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
+    if (!splitResTypes.includes(res.type)) {
+        throw constants_1.ERRORS.TypedError('Runtime', `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
+    }
+};
+const generateEntropy = (len) => {
+    try {
+        return (0, randombytes_1.default)(len);
+    }
+    catch (err) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'generateEntropy: Environment does not support crypto random');
+    }
+};
+const filterForLog = (type, msg) => {
+    const blacklist = {};
+    if (type in blacklist) {
+        return { ...msg, ...blacklist[type] };
+    }
+    return msg;
+};
+class DeviceCommands {
+    constructor(device, transport, sessionId) {
+        this.device = device;
+        this.transport = transport;
+        this.sessionId = sessionId;
+        this.disposed = false;
+    }
+    dispose() {
+        this.disposed = true;
+        this._cancelableRequest = undefined;
+    }
+    isDisposed() {
+        return this.disposed;
+    }
+    async getPublicKey(address_n, coin_name = 'Bitcoin', script_type, show_display) {
+        const response = await this.typedCall('GetPublicKey', 'PublicKey', {
+            address_n,
+            coin_name,
+            script_type,
+            show_display,
+        });
+        return response.message;
+    }
+    async getHDNode(path, coinInfo, validation = true, showOnTrezor = false) {
+        if (!this.device.atLeast(['1.7.2', '2.0.10']) || !coinInfo) {
+            return this.getBitcoinHDNode(path, coinInfo);
+        }
+        let network;
+        if ((0, pathUtils_1.isMultisigPath)(path)) {
+            network = coinInfo.network;
+        }
+        else if ((0, pathUtils_1.isSegwitPath)(path)) {
+            network = (0, coinInfo_1.getSegwitNetwork)(coinInfo);
+        }
+        else if ((0, pathUtils_1.isBech32Path)(path)) {
+            network = (0, coinInfo_1.getBech32Network)(coinInfo);
+        }
+        let scriptType = (0, pathUtils_1.getScriptType)(path);
+        if (!network) {
+            network = coinInfo.network;
+            if (scriptType !== 'SPENDADDRESS') {
+                scriptType = undefined;
+            }
+        }
+        let publicKey;
+        if (showOnTrezor || !validation) {
+            publicKey = await this.getPublicKey(path, coinInfo.name, scriptType, showOnTrezor);
+        }
+        else {
+            const suffix = 0;
+            const childPath = path.concat([suffix]);
+            const resKey = await this.getPublicKey(path, coinInfo.name, scriptType);
+            const childKey = await this.getPublicKey(childPath, coinInfo.name, scriptType);
+            publicKey = hdnodeUtils.xpubDerive(resKey, childKey, suffix, network, coinInfo.network);
+        }
+        const response = {
+            path,
+            serializedPath: (0, pathUtils_1.getSerializedPath)(path),
+            childNum: publicKey.node.child_num,
+            xpub: publicKey.xpub,
+            chainCode: publicKey.node.chain_code,
+            publicKey: publicKey.node.public_key,
+            fingerprint: publicKey.node.fingerprint,
+            depth: publicKey.node.depth,
+        };
+        if (network !== coinInfo.network) {
+            response.xpubSegwit = response.xpub;
+            response.xpub = hdnodeUtils.convertXpub(publicKey.xpub, network, coinInfo.network);
+        }
+        if ((0, pathUtils_1.isTaprootPath)(path)) {
+            response.xpubSegwit = `tr([5c9e228d/86'/${(0, pathUtils_1.fromHardened)(path[1])}'/${(0, pathUtils_1.fromHardened)(path[2])}']${response.xpub}/<0;1>/*)`;
+        }
+        return response;
+    }
+    async getBitcoinHDNode(path, coinInfo, validation = true) {
+        let publicKey;
+        if (!validation) {
+            publicKey = await this.getPublicKey(path);
+        }
+        else {
+            const suffix = 0;
+            const childPath = path.concat([suffix]);
+            const resKey = await this.getPublicKey(path);
+            const childKey = await this.getPublicKey(childPath);
+            publicKey = hdnodeUtils.xpubDerive(resKey, childKey, suffix);
+        }
+        const response = {
+            path,
+            serializedPath: (0, pathUtils_1.getSerializedPath)(path),
+            childNum: publicKey.node.child_num,
+            xpub: coinInfo
+                ? hdnodeUtils.convertBitcoinXpub(publicKey.xpub, coinInfo.network)
+                : publicKey.xpub,
+            chainCode: publicKey.node.chain_code,
+            publicKey: publicKey.node.public_key,
+            fingerprint: publicKey.node.fingerprint,
+            depth: publicKey.node.depth,
+        };
+        if (coinInfo) {
+            const bech32Network = (0, coinInfo_1.getBech32Network)(coinInfo);
+            const segwitNetwork = (0, coinInfo_1.getSegwitNetwork)(coinInfo);
+            if (bech32Network && (0, pathUtils_1.isBech32Path)(path)) {
+                response.xpubSegwit = hdnodeUtils.convertBitcoinXpub(publicKey.xpub, bech32Network);
+            }
+            else if (segwitNetwork && (0, pathUtils_1.isSegwitPath)(path)) {
+                response.xpubSegwit = hdnodeUtils.convertBitcoinXpub(publicKey.xpub, segwitNetwork);
+            }
+        }
+        return response;
+    }
+    async getAddress({ address_n, show_display, multisig, script_type }, coinInfo) {
+        if (!script_type) {
+            script_type = (0, pathUtils_1.getScriptType)(address_n);
+            if (script_type === 'SPENDMULTISIG' && !multisig) {
+                script_type = 'SPENDADDRESS';
+            }
+        }
+        if (multisig && multisig.pubkeys) {
+            multisig.pubkeys.forEach(pk => {
+                if (typeof pk.node === 'string') {
+                    pk.node = hdnodeUtils.xpubToHDNodeType(pk.node, coinInfo.network);
+                }
+            });
+        }
+        const response = await this.typedCall('GetAddress', 'Address', {
+            address_n,
+            coin_name: coinInfo.name,
+            show_display,
+            multisig,
+            script_type: script_type || 'SPENDADDRESS',
+        });
+        return {
+            path: address_n,
+            serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
+            address: response.message.address,
+        };
+    }
+    async ethereumGetAddress({ address_n, show_display }) {
+        const response = await this.typedCall('EthereumGetAddress', 'EthereumAddress', {
+            address_n,
+            show_display,
+        });
+        return {
+            path: address_n,
+            serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
+            address: response.message.address,
+        };
+    }
+    async ethereumGetPublicKey({ address_n, show_display, }) {
+        if (!this.device.atLeast(['1.8.1', '2.1.0'])) {
+            return this.getHDNode(address_n);
+        }
+        const suffix = 0;
+        const childPath = address_n.concat([suffix]);
+        const resKey = await this.typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
+            address_n,
+            show_display,
+        });
+        const childKey = await this.typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
+            address_n: childPath,
+            show_display: false,
+        });
+        const publicKey = hdnodeUtils.xpubDerive(resKey.message, childKey.message, suffix);
+        return {
+            path: address_n,
+            serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
+            childNum: publicKey.node.child_num,
+            xpub: publicKey.xpub,
+            chainCode: publicKey.node.chain_code,
+            publicKey: publicKey.node.public_key,
+            fingerprint: publicKey.node.fingerprint,
+            depth: publicKey.node.depth,
+        };
+    }
+    getDeviceState(networkType) {
+        if (!this.device.atLeast('2.4.3')) {
+            return this._getAddressForNetworkType(networkType);
+        }
+        return this._getAddressForNetworkType();
+    }
+    async call(type, msg = {}) {
+        const logMessage = filterForLog(type, msg);
+        logger.debug('Sending', type, logMessage);
+        try {
+            const promise = this.transport.call(this.sessionId, type, msg, false);
+            this.callPromise = promise;
+            const res = await promise;
+            const logMessage = filterForLog(res.type, res.message);
+            logger.debug('Received', res.type, logMessage);
+            return res;
+        }
+        catch (error) {
+            logger.warn('Received error', error);
+            throw error;
+        }
+    }
+    async typedCall(type, resType, msg) {
+        if (this.disposed) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
+        }
+        const response = await this._commonCall(type, msg);
+        try {
+            assertType(response, resType);
+        }
+        catch (error) {
+            await this.transport.read(this.sessionId, false);
+            throw error;
+        }
+        return response;
+    }
+    async _commonCall(type, msg) {
+        const resp = await this.call(type, msg);
+        return this._filterCommonTypes(resp);
+    }
+    _filterCommonTypes(res) {
+        if (res.type === 'Failure') {
+            const { code } = res.message;
+            let { message } = res.message;
+            if (code === 'Failure_FirmwareError' && !message) {
+                message = 'Firmware installation failed';
+            }
+            if (code === 'Failure_ActionCancelled' && !message) {
+                message = 'Action cancelled by user';
+            }
+            return Promise.reject(new constants_1.ERRORS.TrezorError(code || 'Failure_UnknownCode', message || 'Failure_UnknownMessage'));
+        }
+        if (res.type === 'Features') {
+            return Promise.resolve(res);
+        }
+        if (res.type === 'ButtonRequest') {
+            if (res.message.code === '_Deprecated_ButtonRequest_PassphraseType') {
+                res.message.code = 'ButtonRequest_PassphraseType';
+            }
+            if (res.message.code === 'ButtonRequest_PassphraseEntry') {
+                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE, this.device);
+            }
+            else {
+                this.device.emit(events_1.DEVICE.BUTTON, this.device, res.message);
+            }
+            return this._commonCall('ButtonAck', {});
+        }
+        if (res.type === 'EntropyRequest') {
+            return this._commonCall('EntropyAck', {
+                entropy: generateEntropy(32).toString('hex'),
+            });
+        }
+        if (res.type === 'PinMatrixRequest') {
+            return this._promptPin(res.message.type).then(pin => this._commonCall('PinMatrixAck', { pin }), () => this._commonCall('Cancel', {}));
+        }
+        if (res.type === 'PassphraseRequest') {
+            const state = this.device.getInternalState();
+            const legacy = this.device.useLegacyPassphrase();
+            const legacyT1 = legacy && this.device.isT1();
+            if (legacyT1 && typeof state === 'string') {
+                return this._commonCall('PassphraseAck', { passphrase: state });
+            }
+            if (legacy && res.message._on_device) {
+                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE, this.device);
+                return this._commonCall('PassphraseAck', { _state: state });
+            }
+            return this._promptPassphrase().then(response => {
+                const { passphrase, passphraseOnDevice, cache } = response;
+                if (legacyT1) {
+                    this.device.setInternalState(cache ? passphrase : undefined);
+                    return this._commonCall('PassphraseAck', { passphrase });
+                }
+                if (legacy) {
+                    return this._commonCall('PassphraseAck', { passphrase, _state: state });
+                }
+                return !passphraseOnDevice
+                    ? this._commonCall('PassphraseAck', { passphrase })
+                    : this._commonCall('PassphraseAck', { on_device: true });
+            }, err => this._commonCall('Cancel', {}).catch((e) => {
+                throw err || e;
+            }));
+        }
+        if (res.type === 'Deprecated_PassphraseStateRequest') {
+            const { state } = res.message;
+            this.device.setInternalState(state);
+            return this._commonCall('Deprecated_PassphraseStateAck', {});
+        }
+        if (res.type === 'WordRequest') {
+            return this._promptWord(res.message.type).then(word => this._commonCall('WordAck', { word }), () => this._commonCall('Cancel', {}));
+        }
+        return Promise.resolve(res);
+    }
+    async _getAddressForNetworkType(networkType) {
+        switch (networkType) {
+            case constants_1.NETWORK.TYPES.cardano: {
+                const { message } = await this.typedCall('CardanoGetAddress', 'CardanoAddress', {
+                    address_parameters: {
+                        address_type: 8,
+                        address_n: [(0, pathUtils_1.toHardened)(44), (0, pathUtils_1.toHardened)(1815), (0, pathUtils_1.toHardened)(0), 0, 0],
+                        address_n_staking: [],
+                    },
+                    protocol_magic: 42,
+                    network_id: 0,
+                    derivation_type: 2,
+                });
+                return message.address;
+            }
+            default: {
+                const { message } = await this.typedCall('GetAddress', 'Address', {
+                    address_n: [(0, pathUtils_1.toHardened)(44), (0, pathUtils_1.toHardened)(1), (0, pathUtils_1.toHardened)(0), 0, 0],
+                    coin_name: 'Testnet',
+                    script_type: 'SPENDADDRESS',
+                });
+                return message.address;
+            }
+        }
+    }
+    _promptPin(type) {
+        return new Promise((resolve, reject) => {
+            if (this.device.listenerCount(events_1.DEVICE.PIN) > 0) {
+                this._cancelableRequest = reject;
+                this.device.emit(events_1.DEVICE.PIN, this.device, type, (err, pin) => {
+                    this._cancelableRequest = undefined;
+                    if (err || pin == null) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(pin);
+                    }
+                });
+            }
+            else {
+                console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
+                reject(constants_1.ERRORS.TypedError('Runtime', '_promptPin: PIN callback not configured'));
+            }
+        });
+    }
+    _promptPassphrase() {
+        return new Promise((resolve, reject) => {
+            if (this.device.listenerCount(events_1.DEVICE.PASSPHRASE) > 0) {
+                this._cancelableRequest = reject;
+                this.device.emit(events_1.DEVICE.PASSPHRASE, this.device, (response, error) => {
+                    this._cancelableRequest = undefined;
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(response);
+                    }
+                });
+            }
+            else {
+                console.warn('[DeviceCommands] [call] Passphrase callback not configured, cancelling request');
+                reject(constants_1.ERRORS.TypedError('Runtime', '_promptPassphrase: Passphrase callback not configured'));
+            }
+        });
+    }
+    _promptWord(type) {
+        return new Promise((resolve, reject) => {
+            this._cancelableRequest = reject;
+            this.device.emit(events_1.DEVICE.WORD, this.device, type, (err, word) => {
+                this._cancelableRequest = undefined;
+                if (err || word == null) {
+                    reject(err);
+                }
+                else {
+                    resolve(word.toLocaleLowerCase());
+                }
+            });
+        });
+    }
+    async getAccountDescriptor(coinInfo, indexOrPath, derivationType) {
+        const address_n = Array.isArray(indexOrPath)
+            ? indexOrPath
+            : (0, accountUtils_1.getAccountAddressN)(coinInfo, indexOrPath);
+        if (coinInfo.type === 'bitcoin') {
+            const resp = await this.getHDNode(address_n, coinInfo, false);
+            return {
+                descriptor: resp.xpubSegwit || resp.xpub,
+                legacyXpub: resp.xpub,
+                address_n,
+            };
+        }
+        if (coinInfo.type === 'ethereum') {
+            const resp = await this.ethereumGetAddress({ address_n });
+            return {
+                descriptor: resp.address,
+                address_n,
+            };
+        }
+        if (coinInfo.shortcut === 'ADA' || coinInfo.shortcut === 'tADA') {
+            if (typeof derivationType === 'undefined')
+                throw new Error('Derivation type is not specified');
+            const { message } = await this.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', {
+                address_n,
+                derivation_type: derivationType,
+            });
+            return {
+                descriptor: message.xpub,
+                address_n,
+            };
+        }
+        if (coinInfo.shortcut === 'XRP' || coinInfo.shortcut === 'tXRP') {
+            const { message } = await this.typedCall('RippleGetAddress', 'RippleAddress', {
+                address_n,
+            });
+            return {
+                descriptor: message.address,
+                address_n,
+            };
+        }
+        throw constants_1.ERRORS.TypedError('Runtime', 'DeviceCommands.getAccountDescriptor: unsupported coinInfo.type');
+    }
+    async cancel() {
+        if (this._cancelableRequest) {
+            this._cancelableRequest();
+            this._cancelableRequest = undefined;
+            return;
+        }
+        if (this.disposed) {
+            return;
+        }
+        const { activeName, version } = this.transport;
+        if (activeName &&
+            activeName === 'BridgeTransport' &&
+            (0, versionUtils_1.versionCompare)(version, '2.0.28') < 1) {
+            await this.device.legacyForceRelease();
+        }
+        else {
+            await this.transport.post(this.sessionId, 'Cancel', {}, false);
+            await this.transport.read(this.sessionId, false);
+        }
+    }
+}
+exports.DeviceCommands = DeviceCommands;
+//# sourceMappingURL=DeviceCommands.js.map

package/lib/device/DeviceList.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
+import { TRANSPORT, DEVICE, TransportInfo } from '../events';
+import { DescriptorStream } from './DescriptorStream';
+import { Device } from './Device';
+import type { Device as DeviceTyped } from '../types';
+import type { Controller } from './AbortController';
+declare type LowLevelPlugin = {
+    name: 'WebUsbPlugin' | 'ReactNativePlugin';
+    unreadableHidDeviceChange: {
+        on: (event: string, fn: any) => void;
+    };
+    unreadableHidDevice: boolean;
+};
+interface DeviceListEvents {
+    [TRANSPORT.START]: TransportInfo;
+    [TRANSPORT.ERROR]: string;
+    [TRANSPORT.STREAM]: DescriptorStream;
+    [DEVICE.CONNECT]: DeviceTyped;
+    [DEVICE.CONNECT_UNACQUIRED]: DeviceTyped;
+    [DEVICE.DISCONNECT]: DeviceTyped;
+    [DEVICE.CHANGED]: DeviceTyped;
+    [DEVICE.RELEASED]: DeviceTyped;
+    [DEVICE.ACQUIRED]: DeviceTyped;
+}
+export interface DeviceList {
+    on<K extends keyof DeviceListEvents>(type: K, listener: (event: DeviceListEvents[K]) => void): this;
+    off<K extends keyof DeviceListEvents>(type: K, listener: (event: DeviceListEvents[K]) => void): this;
+    emit<K extends keyof DeviceListEvents>(type: K, args: DeviceListEvents[K]): boolean;
+}
+export declare class DeviceList extends EventEmitter {
+    transport: Transport;
+    transportPlugin: LowLevelPlugin | typeof undefined;
+    stream: DescriptorStream;
+    devices: {
+        [path: string]: Device;
+    };
+    creatingDevicesDescriptors: {
+        [k: string]: DeviceDescriptor;
+    };
+    defaultMessages: JSON | Record<string, any>;
+    currentMessages: JSON | Record<string, any>;
+    hasCustomMessages: boolean;
+    transportStartPending: number;
+    penalizedDevices: {
+        [deviceID: string]: number;
+    };
+    fetchController?: Controller | null;
+    constructor();
+    init(): Promise<void>;
+    reconfigure(messages: JSON | Record<string, any> | number[], custom?: boolean): Promise<void>;
+    restoreMessages(): Promise<void>;
+    resolveTransportEvent(): void;
+    waitForTransportFirstEvent(): Promise<void>;
+    _initStream(): void;
+    _createAndSaveDevice(descriptor: DeviceDescriptor): Promise<void>;
+    _createUnacquiredDevice(descriptor: DeviceDescriptor): Device;
+    _createUnreadableDevice(descriptor: DeviceDescriptor, unreadableError: string): Device;
+    getDevice(path: string): Device;
+    getFirstDevicePath(): string;
+    asArray(): DeviceTyped[];
+    allDevices(): Device[];
+    length(): number;
+    transportType(): string;
+    getTransportInfo(): TransportInfo;
+    dispose(): void;
+    disconnectDevices(): void;
+    enumerate(): void;
+    addAuthPenalty(device: Device): void;
+    getAuthPenalty(): number;
+    removeAuthPenalty(device: Device): void;
+}
+export declare const getDeviceList: () => Promise<DeviceList>;
+export {};
+//# sourceMappingURL=DeviceList.d.ts.map