@trezor/connect 9.5.3 → 9.5.4

package/lib/device/DeviceCommands.js

@@ -2,80 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceCommands = void 0;
 const tslib_1 = require("tslib");
-const protobuf_1 = require("@trezor/protobuf");
-const schema_utils_1 = require("@trezor/schema-utils");
-const utils_1 = require("@trezor/utils");
 const constants_1 = require("../constants");
-const resolveDescriptorForTaproot_1 = require("./resolveDescriptorForTaproot");
 const coinInfo_1 = require("../data/coinInfo");
-const events_1 = require("../events");
-const prompts_1 = require("./prompts");
+const resolveDescriptorForTaproot_1 = require("../device/resolveDescriptorForTaproot");
 const accountUtils_1 = require("../utils/accountUtils");
-const debug_1 = require("../utils/debug");
 const hdnodeUtils = tslib_1.__importStar(require("../utils/hdnodeUtils"));
 const pathUtils_1 = require("../utils/pathUtils");
-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 filterForLog = (type, msg) => {
-    const blacklist = {
-        PassphraseAck: {
-            passphrase: '(redacted...)',
-        },
-        CipheredKeyValue: {
-            value: '(redacted...)',
-        },
-        GetPublicKey: {
-            address_n: '(redacted...)',
-        },
-        PublicKey: {
-            node: '(redacted...)',
-            xpub: '(redacted...)',
-        },
-        DecryptedMessage: {
-            message: '(redacted...)',
-            address: '(redacted...)',
-        },
-        Features: '(redacted...)',
-    };
-    if (type in blacklist) {
-        if (typeof blacklist[type] === 'string') {
-            return blacklist[type];
-        }
-        return { ...msg, ...blacklist[type] };
-    }
-    return msg;
-};
-class DeviceCommands {
-    device;
-    transport;
-    transportSession;
-    disposed;
-    callPromise;
-    constructor(device, transport, transportSession) {
-        this.device = device;
-        this.transport = transport;
-        this.transportSession = transportSession;
-        this.disposed = false;
-    }
-    dispose() {
-        this.disposed = true;
-    }
-    isDisposed() {
-        return this.disposed;
-    }
-    unlockPath(params) {
-        return this.typedCall('UnlockPath', 'UnlockedPathRequest', params);
-    }
-    async getPublicKey(params, unlockPath) {
-        if (unlockPath) {
-            await this.unlockPath(unlockPath);
-        }
-        const response = await this.typedCall('GetPublicKey', 'PublicKey', {
+const DeviceCommands = (deviceTypedCall) => {
+    const typedCall = deviceTypedCall.typedCall.bind(deviceTypedCall);
+    const unlockPath = (params) => typedCall('UnlockPath', 'UnlockedPathRequest', params);
+    const getPublicKey = async (params, unlock) => {
+        if (unlock) {
+            await unlockPath(unlock);
+        }
+        const response = await typedCall('GetPublicKey', 'PublicKey', {
             address_n: params.address_n,
             coin_name: params.coin_name || 'Bitcoin',
             script_type: params.script_type,
@@ -84,10 +24,10 @@ class DeviceCommands {
             ecdsa_curve_name: params.ecdsa_curve_name,
         });
         return response.message;
-    }
-    async getHDNode(params, options) {
+    };
+    const getHDNode = async (params, options) => {
         const path = params.address_n;
-        const { coinInfo, unlockPath } = options;
+        const { coinInfo, unlockPath: unlock } = options;
         const validation = typeof options.validation === 'boolean' ? options.validation : true;
         let network = null;
         if (!params.script_type) {
@@ -107,13 +47,13 @@ class DeviceCommands {
         }
         let publicKey;
         if (params.show_display || !validation) {
-            publicKey = await this.getPublicKey(params, unlockPath);
+            publicKey = await getPublicKey(params, unlock);
         }
         else {
             const suffix = 0;
             const childPath = path.concat([suffix]);
-            const resKey = await this.getPublicKey(params, unlockPath);
-            const childKey = await this.getPublicKey({ ...params, address_n: childPath }, unlockPath);
+            const resKey = await getPublicKey(params, unlock);
+            const childKey = await getPublicKey({ ...params, address_n: childPath }, unlock);
             publicKey = hdnodeUtils.xpubDerive(resKey, childKey, suffix, network, coinInfo.network);
         }
         const response = {
@@ -125,6 +65,7 @@ class DeviceCommands {
             publicKey: publicKey.node.public_key,
             fingerprint: publicKey.node.fingerprint,
             depth: publicKey.node.depth,
+            descriptor: publicKey.descriptor,
         };
         if (network !== coinInfo.network) {
             response.xpubSegwit = response.xpub;
@@ -139,8 +80,8 @@ class DeviceCommands {
             response.descriptorChecksum = checksum;
         }
         return response;
-    }
-    async getAddress({ address_n, show_display, multisig, script_type, chunkify }, coinInfo) {
+    };
+    const getAddress = async ({ address_n, show_display, multisig, script_type, chunkify }, coinInfo) => {
         if (!script_type) {
             script_type = (0, pathUtils_1.getScriptType)(address_n);
             if (script_type === 'SPENDMULTISIG' && !multisig) {
@@ -154,7 +95,7 @@ class DeviceCommands {
                 }
             });
         }
-        const response = await this.typedCall('GetAddress', 'Address', {
+        const response = await typedCall('GetAddress', 'Address', {
             address_n,
             coin_name: coinInfo.name,
             show_display,
@@ -162,51 +103,28 @@ class DeviceCommands {
             script_type: script_type || 'SPENDADDRESS',
             chunkify,
         });
-        return {
-            path: address_n,
-            serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
-            address: response.message.address,
-        };
-    }
-    async ethereumGetAddress({ address_n, show_display, encoded_network, chunkify, }) {
-        const response = await this.typedCall('EthereumGetAddress', 'EthereumAddress', {
-            address_n,
-            show_display,
-            encoded_network,
-            chunkify,
-        });
-        return {
-            path: address_n,
-            serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
-            address: response.message.address,
-        };
-    }
-    async ethereumGetPublicKey({ address_n, show_display, }) {
+        return response.message;
+    };
+    const ethereumGetAddress = async (params) => {
+        const response = await typedCall('EthereumGetAddress', 'EthereumAddress', params);
+        return response.message;
+    };
+    const ethereumGetPublicKey = async ({ address_n, show_display, }) => {
         const suffix = 0;
         const childPath = address_n.concat([suffix]);
-        const resKey = await this.typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
+        const resKey = await typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
             address_n,
             show_display,
         });
-        const childKey = await this.typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
+        const childKey = await 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,
-        };
-    }
-    async preauthorize(throwError) {
+        return hdnodeUtils.xpubDerive(resKey.message, childKey.message, suffix);
+    };
+    const preauthorize = async (throwError) => {
         try {
-            await this.typedCall('DoPreauthorized', 'PreauthorizedRequest', {});
+            await typedCall('DoPreauthorized', 'PreauthorizedRequest', {});
             return true;
         }
         catch (error) {
@@ -214,123 +132,13 @@ class DeviceCommands {
                 throw error;
             return false;
         }
-    }
-    getDeviceState() {
-        return this._getAddress();
-    }
-    async call(type, msg) {
-        logger.debug('Sending', type, filterForLog(type, msg));
-        this.callPromise = this.transport.call({
-            session: this.transportSession,
-            name: type,
-            data: msg,
-            protocol: this.device.protocol,
-        });
-        const res = await this.callPromise;
-        this.callPromise = undefined;
-        if (!res.success) {
-            logger.warn('Received transport error', res.error, res.message);
-            throw new Error(res.error, { cause: 'transport-error' });
-        }
-        logger.debug('Received', res.payload.type, filterForLog(res.payload.type, res.payload.message));
-        return res.payload;
-    }
-    async typedCall(type, resType, msg = {}) {
-        if (this.disposed) {
-            throw constants_1.ERRORS.TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
-        }
-        (0, schema_utils_1.Assert)(protobuf_1.MessagesSchema.MessageType.properties[type], msg);
-        const response = await this._commonCall(type, msg);
-        try {
-            assertType(response, resType);
-        }
-        catch (error) {
-            const abortController = new AbortController();
-            const timeout = setTimeout(() => {
-                abortController.abort();
-            }, 500);
-            await this.transport
-                .receive({
-                session: this.transportSession,
-                protocol: this.device.protocol,
-                signal: abortController.signal,
-            })
-                .finally(() => {
-                clearTimeout(timeout);
-            });
-            throw error;
-        }
-        return response;
-    }
-    async _commonCall(type, msg) {
-        if (this.disposed) {
-            throw constants_1.ERRORS.TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
-        }
-        const resp = await this.call(type, msg);
-        return this._filterCommonTypes(resp);
-    }
-    _filterCommonTypes(res) {
-        this.device.clearCancelableAction();
-        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') {
-            this.device.setCancelableAction(() => this.cancelWithFallback());
-            if (res.message.code === 'ButtonRequest_PassphraseEntry') {
-                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
-            }
-            else {
-                this.device.emit(events_1.DEVICE.BUTTON, { device: this.device, payload: res.message });
-            }
-            return this._commonCall('ButtonAck', {});
-        }
-        if (res.type === 'PinMatrixRequest') {
-            return (0, prompts_1.promptPin)(this.device, res.message.type).then(promptRes => !promptRes.success
-                ? Promise.reject(promptRes.error)
-                : this._commonCall('PinMatrixAck', { pin: promptRes.payload }).then(response => (this.device.features.unlocked
-                    ? Promise.resolve()
-                    :
-                        this.device.getFeatures()).then(() => response)));
-        }
-        if (res.type === 'PassphraseRequest') {
-            return (0, prompts_1.promptPassphrase)(this.device).then(promptRes => !promptRes.success
-                ? Promise.reject(promptRes.error)
-                : this._commonCall('PassphraseAck', promptRes.payload.passphraseOnDevice
-                    ? { on_device: true }
-                    : { passphrase: promptRes.payload.value.normalize('NFKD') }));
-        }
-        if (res.type === 'WordRequest') {
-            return (0, prompts_1.promptWord)(this.device, res.message.type).then(promptRes => !promptRes.success
-                ? Promise.reject(promptRes.error)
-                : this._commonCall('WordAck', { word: promptRes.payload }));
-        }
-        return Promise.resolve(res);
-    }
-    async _getAddress() {
-        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;
-    }
-    async getAccountDescriptor(coinInfo, indexOrPath, derivationType) {
+    };
+    const getAccountDescriptor = async (coinInfo, indexOrPath, derivationType = constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR) => {
         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, validation: false });
+            const resp = await getHDNode({ address_n }, { coinInfo, validation: false });
             return {
                 descriptor: resp.xpubSegwit || resp.xpub,
                 legacyXpub: resp.xpub,
@@ -339,16 +147,16 @@ class DeviceCommands {
             };
         }
         if (coinInfo.type === 'ethereum') {
-            const resp = await this.ethereumGetAddress({ address_n });
+            const { message } = await typedCall('EthereumGetAddress', 'EthereumAddress', {
+                address_n,
+            });
             return {
-                descriptor: resp.address,
+                descriptor: message.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', {
+            const { message } = await typedCall('CardanoGetPublicKey', 'CardanoPublicKey', {
                 address_n,
                 derivation_type: derivationType,
             });
@@ -358,7 +166,7 @@ class DeviceCommands {
             };
         }
         if (coinInfo.shortcut === 'XRP' || coinInfo.shortcut === 'tXRP') {
-            const { message } = await this.typedCall('RippleGetAddress', 'RippleAddress', {
+            const { message } = await typedCall('RippleGetAddress', 'RippleAddress', {
                 address_n,
             });
             return {
@@ -367,7 +175,7 @@ class DeviceCommands {
             };
         }
         if (coinInfo.shortcut === 'SOL' || coinInfo.shortcut === 'DSOL') {
-            const { message } = await this.typedCall('SolanaGetAddress', 'SolanaAddress', {
+            const { message } = await typedCall('SolanaGetAddress', 'SolanaAddress', {
                 address_n,
             });
             return {
@@ -376,35 +184,18 @@ class DeviceCommands {
             };
         }
         throw constants_1.ERRORS.TypedError('Runtime', 'DeviceCommands.getAccountDescriptor: unsupported coinInfo.type');
-    }
-    async cancelWithFallback() {
-        const { name, version } = this.transport;
-        if (name === 'BridgeTransport' && !utils_1.versionUtils.isNewer(version, '2.0.28')) {
-            try {
-                await (0, utils_1.resolveAfter)(1);
-                await this.device.acquire();
-                await (0, prompts_1.cancelPrompt)(this.device, false);
-            }
-            catch {
-            }
-        }
-        else {
-            return (0, prompts_1.cancelPrompt)(this.device, false);
-        }
-    }
-    async cancel() {
-        if (this.disposed) {
-            return;
-        }
-        this.dispose();
-        if (this.callPromise) {
-            try {
-                await this.callPromise;
-            }
-            catch {
-            }
-        }
-    }
-}
+    };
+    return {
+        unlockPath,
+        getPublicKey,
+        getAddress,
+        ethereumGetPublicKey,
+        ethereumGetAddress,
+        getHDNode,
+        preauthorize,
+        getAccountDescriptor,
+        typedCall,
+    };
+};
 exports.DeviceCommands = DeviceCommands;
 //# sourceMappingURL=DeviceCommands.js.map