@trezor/connect 9.4.3-beta.1 → 9.4.3-beta.2

package/lib/api/cardano/cardanoTokenBundle.d.ts

@@ -1,12 +1,12 @@
-import { CardanoAssetGroup } from '../../types/api/cardano';
 import { Static } from '@trezor/schema-utils';
+import { CardanoAssetGroup } from '../../types/api/cardano';
 export type AssetGroupWithTokens = Static<typeof AssetGroupWithTokens>;
 export declare const AssetGroupWithTokens: import("@trezor/schema-utils").TObject<{
-    policyId: import("@sinclair/typebox").TString;
-    tokens: import("@sinclair/typebox").TArray<import("@trezor/schema-utils").TObject<{
-        asset_name_bytes: import("@sinclair/typebox").TString;
-        amount: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
-        mint_amount: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
+    policyId: import("@trezor/schema-utils").TString;
+    tokens: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+        asset_name_bytes: import("@trezor/schema-utils").TString;
+        amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
+        mint_amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
     }>>;
 }>;
 export declare const tokenBundleToProto: (tokenBundle: CardanoAssetGroup[]) => AssetGroupWithTokens[];

package/lib/api/cardano/cardanoTokenBundle.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokenBundleToProto = exports.AssetGroupWithTokens = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
 const constants_1 = require("../../constants");
 const cardano_1 = require("../../types/api/cardano");
-const schema_utils_1 = require("@trezor/schema-utils");
 exports.AssetGroupWithTokens = schema_utils_1.Type.Object({
     policyId: schema_utils_1.Type.String(),
     tokens: schema_utils_1.Type.Array(constants_1.PROTO.CardanoToken, { minItems: 1 }),

package/lib/api/changeLanguage.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../core/AbstractMethod");
 const events_1 = require("../events");
-const schema_utils_1 = require("@trezor/schema-utils");
 const changeLanguage_1 = require("../types/api/changeLanguage");
 class ChangeLanguage extends AbstractMethod_1.AbstractMethod {
     init() {

package/lib/api/changePin.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const AbstractMethod_1 = require("../core/AbstractMethod");
 const schema_utils_1 = require("@trezor/schema-utils");
+const AbstractMethod_1 = require("../core/AbstractMethod");
 const constants_1 = require("../constants");
 class ChangePin extends AbstractMethod_1.AbstractMethod {
     init() {

package/lib/api/cipherKeyValue.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("@trezor/schema-utils");
 const events_1 = require("../events");
 const AbstractMethod_1 = require("../core/AbstractMethod");
 const paramsValidator_1 = require("./common/paramsValidator");
 const pathUtils_1 = require("../utils/pathUtils");
-const schema_utils_1 = require("@trezor/schema-utils");
 const params_1 = require("../types/params");
 const cipherKeyValue_1 = require("../types/api/cipherKeyValue");
 class CipherKeyValue extends AbstractMethod_1.AbstractMethod {

package/lib/api/common/paramsValidator.js

@@ -24,7 +24,7 @@ function validateParams(params, schema) {
                     validateParams(p, [{ name: field.name, type: t }]);
                     return count + 1;
                 }
-                catch (e) {
+                catch {
                     return count;
                 }
             }, 0);

package/lib/api/composeTransaction.d.ts

@@ -1,8 +1,8 @@
 import { BigNumber } from '@trezor/utils/lib/bigNumber';
+import type { ComposeOutput, TransactionInputOutputSortingStrategy } from '@trezor/utxo-lib';
 import { AbstractMethod } from '../core/AbstractMethod';
 import { Discovery } from './common/Discovery';
 import { TransactionComposer } from './bitcoin';
-import type { ComposeOutput } from '@trezor/utxo-lib';
 import type { BitcoinNetworkInfo, DiscoveryAccount, AccountUtxo } from '../types';
 import type { SignedTransaction, PrecomposeParams, ComposeResult, PrecomposedResult } from '../types/api/composeTransaction';
 type Params = {
@@ -15,9 +15,15 @@ type Params = {
     baseFee?: PrecomposeParams['baseFee'];
     floorBaseFee?: PrecomposeParams['floorBaseFee'];
     sequence?: PrecomposeParams['sequence'];
-    skipPermutation?: PrecomposeParams['skipPermutation'];
     total: BigNumber;
-};
+    sortingStrategy: PrecomposeParams['sortingStrategy'];
+} & ({
+    skipPermutation?: PrecomposeParams['skipPermutation'];
+    sortingStrategy?: undefined;
+} | {
+    skipPermutation?: undefined;
+    sortingStrategy?: TransactionInputOutputSortingStrategy;
+});
 export default class ComposeTransaction extends AbstractMethod<'composeTransaction', Params> {
     discovery?: Discovery;
     init(): void;

package/lib/api/composeTransaction.js

@@ -13,6 +13,7 @@ const formatUtils_1 = require("../utils/formatUtils");
 const coinInfo_1 = require("../data/coinInfo");
 const BlockchainLink_1 = require("../backend/BlockchainLink");
 const bitcoin_1 = require("./bitcoin");
+const utxo_1 = require("../constants/utxo");
 class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
@@ -28,6 +29,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
             { name: 'floorBaseFee', type: 'boolean' },
             { name: 'sequence', type: 'number' },
             { name: 'skipPermutation', type: 'boolean' },
+            { name: 'sortingStrategy', type: 'string' },
         ]);
         const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
         if (!coinInfo) {
@@ -55,7 +57,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
             baseFee: payload.baseFee,
             floorBaseFee: payload.floorBaseFee,
             sequence: payload.sequence,
-            skipPermutation: payload.skipPermutation,
+            sortingStrategy: payload.skipPermutation === true ? 'none' : payload.sortingStrategy,
             push: typeof payload.push === 'boolean' ? payload.push : false,
             total,
         };
@@ -75,7 +77,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
         return (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
     }
     async precompose(account, feeLevels) {
-        const { coinInfo, outputs, baseFee, skipPermutation } = this.params;
+        const { coinInfo, outputs, baseFee, sortingStrategy } = this.params;
         const address_n = pathUtils.validatePath(account.path);
         const composer = new bitcoin_1.TransactionComposer({
             account: {
@@ -89,7 +91,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
             coinInfo,
             outputs,
             baseFee,
-            skipPermutation,
+            sortingStrategy: sortingStrategy !== null && sortingStrategy !== void 0 ? sortingStrategy : utxo_1.DEFAULT_SORTING_STRATEGY,
         });
         const blockchain = await this.getBlockchain();
         await composer.init(blockchain);
@@ -188,13 +190,14 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
         };
     }
     async selectFee(account, utxos) {
-        const { coinInfo, outputs } = this.params;
+        const { coinInfo, outputs, sortingStrategy, skipPermutation } = this.params;
         const blockchain = await this.getBlockchain();
         const composer = new bitcoin_1.TransactionComposer({
             account,
             utxos,
             coinInfo,
             outputs,
+            sortingStrategy: skipPermutation === true ? 'none' : sortingStrategy !== null && sortingStrategy !== void 0 ? sortingStrategy : utxo_1.DEFAULT_SORTING_STRATEGY,
         });
         await composer.init(blockchain);
         const hasFunds = composer.composeAllFeeLevels();

package/lib/api/eos/api/eosGetPublicKey.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const events_1 = require("../../../events");
-const schema_utils_1 = require("@trezor/schema-utils");
 const types_1 = require("../../../types");
 class EosGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
+        this.requiredDeviceCapabilities = ['Capability_EOS'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
         this.hasBundle = !!this.payload.bundle;
         const payload = !this.payload.bundle

package/lib/api/eos/api/eosSignTransaction.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const helper = tslib_1.__importStar(require("../eosSignTx"));
-const schema_utils_1 = require("@trezor/schema-utils");
 const eos_1 = require("../../../types/api/eos");
 class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
+        this.requiredDeviceCapabilities = ['Capability_EOS'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
         const { payload } = this;
         (0, schema_utils_1.AssertWeak)(eos_1.EosSignTransaction, payload);

package/lib/api/eos/eosSignTx.d.ts

@@ -32,8 +32,8 @@ export declare const validate: (tx: EosSDKTransaction) => {
             name: string;
             owner: {
                 keys: {
-                    address_n?: number[] | undefined;
                     type?: number | undefined;
+                    address_n?: number[] | undefined;
                     weight: number;
                     key: string;
                 }[];
@@ -53,8 +53,8 @@ export declare const validate: (tx: EosSDKTransaction) => {
             creator: string;
             active: {
                 keys: {
-                    address_n?: number[] | undefined;
                     type?: number | undefined;
+                    address_n?: number[] | undefined;
                     weight: number;
                     key: string;
                 }[];
@@ -125,8 +125,8 @@ export declare const validate: (tx: EosSDKTransaction) => {
             parent: string;
             auth: {
                 keys: {
-                    address_n?: number[] | undefined;
                     type?: number | undefined;
+                    address_n?: number[] | undefined;
                     weight: number;
                     key: string;
                 }[];

package/lib/api/ethereum/api/ethereumGetAddress.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const pathUtils_1 = require("../../../utils/pathUtils");
@@ -9,7 +10,6 @@ const formatUtils_1 = require("../../../utils/formatUtils");
 const constants_1 = require("../../../constants");
 const events_1 = require("../../../events");
 const ethereumDefinitions_1 = require("../ethereumDefinitions");
-const schema_utils_1 = require("@trezor/schema-utils");
 const types_1 = require("../../../types");
 const getAddress_1 = require("../../../types/api/getAddress");
 class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
@@ -20,6 +20,7 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
     init() {
         this.noBackupConfirmationMode = 'always';
         this.requiredPermissions = ['read'];
+        this.requiredDeviceCapabilities = ['Capability_Ethereum'];
         this.hasBundle = !!this.payload.bundle;
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }

package/lib/api/ethereum/api/ethereumGetPublicKey.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const ethereumUtils_1 = require("../../../utils/ethereumUtils");
 const coinInfo_1 = require("../../../data/coinInfo");
 const events_1 = require("../../../events");
-const schema_utils_1 = require("@trezor/schema-utils");
 const types_1 = require("../../../types");
 class EthereumGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
+        this.requiredDeviceCapabilities = ['Capability_Ethereum'];
         this.hasBundle = !!this.payload.bundle;
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }

package/lib/api/ethereum/api/ethereumSignMessage.d.ts

@@ -1,7 +1,7 @@
+import { MessagesSchema } from '@trezor/protobuf';
 import { AbstractMethod } from '../../../core/AbstractMethod';
 import type { PROTO } from '../../../constants';
 import { EthereumNetworkInfo } from '../../../types';
-import { MessagesSchema } from '@trezor/protobuf';
 type Params = PROTO.EthereumSignMessage & {
     network?: EthereumNetworkInfo;
     definitions?: MessagesSchema.EthereumDefinitions;

package/lib/api/ethereum/api/ethereumSignMessage.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const pathUtils_1 = require("../../../utils/pathUtils");
@@ -8,10 +9,10 @@ const ethereumUtils_1 = require("../../../utils/ethereumUtils");
 const formatUtils_1 = require("../../../utils/formatUtils");
 const ethereumDefinitions_1 = require("../ethereumDefinitions");
 const types_1 = require("../../../types");
-const schema_utils_1 = require("@trezor/schema-utils");
 class EthereumSignMessage extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
+        this.requiredDeviceCapabilities = ['Capability_Ethereum'];
         const { payload } = this;
         (0, schema_utils_1.Assert)(types_1.EthereumSignMessage, payload);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);

package/lib/api/ethereum/api/ethereumSignTransaction.d.ts

@@ -1,7 +1,7 @@
+import { MessagesSchema } from '@trezor/protobuf';
 import { AbstractMethod } from '../../../core/AbstractMethod';
 import type { EthereumTransaction, EthereumTransactionEIP1559 } from '../../../types/api/ethereum';
 import { EthereumNetworkInfo } from '../../../types';
-import { MessagesSchema } from '@trezor/protobuf';
 type Params = {
     path: number[];
     network?: EthereumNetworkInfo;

package/lib/api/ethereum/api/ethereumSignTransaction.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const pathUtils_1 = require("../../../utils/pathUtils");
@@ -10,7 +11,6 @@ const formatUtils_1 = require("../../../utils/formatUtils");
 const helper = tslib_1.__importStar(require("../ethereumSignTx"));
 const ethereumDefinitions_1 = require("../ethereumDefinitions");
 const types_1 = require("../../../types");
-const schema_utils_1 = require("@trezor/schema-utils");
 const strip = (0, formatUtils_1.deepTransform)(value => {
     let stripped = (0, formatUtils_1.stripHexPrefix)(value);
     if (stripped.length % 2 !== 0) {
@@ -21,6 +21,7 @@ const strip = (0, formatUtils_1.deepTransform)(value => {
 class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
+        this.requiredDeviceCapabilities = ['Capability_Ethereum'];
         const { payload } = this;
         (0, schema_utils_1.Assert)(types_1.EthereumSignTransaction, payload);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);
@@ -60,14 +61,19 @@ class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
     }
     async run() {
         const { type, tx, definitions, chunkify } = this.params;
-        const signature = type === 'eip1559'
-            ? await helper.ethereumSignTxEIP1559(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, chunkify, tx.data, tx.accessList, definitions)
-            : await helper.ethereumSignTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.gasPrice, tx.nonce, tx.chainId, chunkify, tx.data, tx.txType, definitions);
-        const serializedTx = helper.serializeEthereumTx({
+        const isLegacy = type === 'legacy';
+        const signature = isLegacy
+            ? await helper.ethereumSignTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.gasPrice, tx.nonce, tx.chainId, chunkify, tx.data, tx.txType, definitions)
+            : await helper.ethereumSignTxEIP1559(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, chunkify, tx.data, tx.accessList, definitions);
+        const txData = {
             ...tx,
             ...signature,
-            type: type === 'legacy' ? 0 : 2,
-        }, tx.chainId);
+            type: isLegacy ? 0 : 2,
+            gasPrice: isLegacy ? tx.gasPrice : null,
+            maxFeePerGas: isLegacy ? tx.maxFeePerGas : tx.maxPriorityFeePerGas,
+            maxPriorityFeePerGas: !isLegacy ? tx.maxPriorityFeePerGas : undefined,
+        };
+        const serializedTx = helper.serializeEthereumTx(txData, tx.chainId);
         return { ...signature, serializedTx };
     }
 }

package/lib/api/ethereum/api/ethereumSignTypedData.d.ts

@@ -1,92 +1,93 @@
+import { MessagesSchema } from '@trezor/protobuf';
 import { AbstractMethod } from '../../../core/AbstractMethod';
 import { EthereumSignTypedDataTypes, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '../../../types/api/ethereum';
 import { EthereumNetworkInfo } from '../../../types';
-import { MessagesSchema } from '@trezor/protobuf';
 type Params = (Omit<EthereumSignTypedDataParams<EthereumSignTypedDataTypes>, 'path'> | Omit<EthereumSignTypedHashParams<EthereumSignTypedDataTypes>, 'path'>) & {
     address_n: number[];
     network?: EthereumNetworkInfo;
     definitions?: MessagesSchema.EthereumDefinitions;
 };
-declare const Params: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TUnion<[import("@trezor/schema-utils").TObject<{
+declare const Params: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{
     data: import("@trezor/schema-utils").TObject<{
         types: import("@trezor/schema-utils").TObject<{
-            EIP712Domain: import("@sinclair/typebox").TArray<import("@trezor/schema-utils").TObject<{
-                name: import("@sinclair/typebox").TString;
-                type: import("@sinclair/typebox").TString;
+            EIP712Domain: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+                name: import("@trezor/schema-utils").TString;
+                type: import("@trezor/schema-utils").TString;
             }>>;
         }>;
-        primaryType: import("@sinclair/typebox").TString;
+        primaryType: import("@trezor/schema-utils").TString;
         domain: import("@trezor/schema-utils").TObject<{
-            name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            version: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>>;
-            verifyingContract: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            salt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer, import("@sinclair/typebox").TString]>>;
+            name: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            version: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            chainId: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TNumber, import("@trezor/schema-utils").TBigInt, import("@trezor/schema-utils").TString]>>;
+            verifyingContract: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            salt: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer, import("@trezor/schema-utils").TString]>>;
         }>;
         message: import("@trezor/schema-utils").TObject<{}>;
     }>;
-    metamask_v4_compat: import("@sinclair/typebox").TBoolean;
-    domain_separator_hash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
-    message_hash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    metamask_v4_compat: import("@trezor/schema-utils").TBoolean;
+    domain_separator_hash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+    message_hash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
 }>, import("@trezor/schema-utils").TObject<{
     data: import("@trezor/schema-utils").TObject<{
         types: import("@trezor/schema-utils").TObject<{
-            EIP712Domain: import("@sinclair/typebox").TArray<import("@trezor/schema-utils").TObject<{
-                name: import("@sinclair/typebox").TString;
-                type: import("@sinclair/typebox").TString;
+            EIP712Domain: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+                name: import("@trezor/schema-utils").TString;
+                type: import("@trezor/schema-utils").TString;
             }>>;
         }>;
-        primaryType: import("@sinclair/typebox").TString;
+        primaryType: import("@trezor/schema-utils").TString;
         domain: import("@trezor/schema-utils").TObject<{
-            name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            version: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>>;
-            verifyingContract: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            salt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer, import("@sinclair/typebox").TString]>>;
+            name: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            version: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            chainId: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TNumber, import("@trezor/schema-utils").TBigInt, import("@trezor/schema-utils").TString]>>;
+            verifyingContract: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            salt: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer, import("@trezor/schema-utils").TString]>>;
         }>;
         message: import("@trezor/schema-utils").TObject<{}>;
     }>;
-    metamask_v4_compat: import("@sinclair/typebox").TBoolean;
-    domain_separator_hash: import("@sinclair/typebox").TString;
-    message_hash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    metamask_v4_compat: import("@trezor/schema-utils").TBoolean;
+    domain_separator_hash: import("@trezor/schema-utils").TString;
+    message_hash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
 }>]>, import("@trezor/schema-utils").TObject<{
-    address_n: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
-    network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TIntersect<[import("@trezor/schema-utils").TObject<{
-        label: import("@sinclair/typebox").TString;
-        name: import("@sinclair/typebox").TString;
-        shortcut: import("@sinclair/typebox").TString;
-        slip44: import("@sinclair/typebox").TNumber;
+    address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+    network: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+        label: import("@trezor/schema-utils").TString;
+        name: import("@trezor/schema-utils").TString;
+        shortcut: import("@trezor/schema-utils").TString;
+        slip44: import("@trezor/schema-utils").TNumber;
         support: import("@trezor/schema-utils").TObject<{
-            connect: import("@sinclair/typebox").TBoolean;
-            T1B1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
-            T2T1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
-            T2B1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
-            T3B1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
-            T3T1: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<false>]>;
+            connect: import("@trezor/schema-utils").TBoolean;
+            T1B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+            T2T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+            T2B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+            T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+            T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+            T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         }>;
-        decimals: import("@sinclair/typebox").TNumber;
-        blockchainLink: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils").TObject<{
-            type: import("@sinclair/typebox").TString;
-            url: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        decimals: import("@trezor/schema-utils").TNumber;
+        blockchainLink: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            type: import("@trezor/schema-utils").TString;
+            url: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
         }>>;
-        blockTime: import("@sinclair/typebox").TNumber;
-        minFee: import("@sinclair/typebox").TNumber;
-        maxFee: import("@sinclair/typebox").TNumber;
-        defaultFees: import("@sinclair/typebox").TArray<import("@trezor/schema-utils").TObject<{
-            label: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"normal">, import("@sinclair/typebox").TLiteral<"economy">, import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"custom">]>;
-            feePerUnit: import("@sinclair/typebox").TString;
-            blocks: import("@sinclair/typebox").TNumber;
-            feeLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            feePerTx: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        blockTime: import("@trezor/schema-utils").TNumber;
+        minFee: import("@trezor/schema-utils").TNumber;
+        maxFee: import("@trezor/schema-utils").TNumber;
+        defaultFees: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+            label: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"high">, import("@trezor/schema-utils").TLiteral<"normal">, import("@trezor/schema-utils").TLiteral<"economy">, import("@trezor/schema-utils").TLiteral<"low">, import("@trezor/schema-utils").TLiteral<"custom">]>;
+            feePerUnit: import("@trezor/schema-utils").TString;
+            blocks: import("@trezor/schema-utils").TNumber;
+            feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         }>>;
     }>, import("@trezor/schema-utils").TObject<{
-        type: import("@sinclair/typebox").TLiteral<"ethereum">;
-        chainId: import("@sinclair/typebox").TNumber;
-        network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+        type: import("@trezor/schema-utils").TLiteral<"ethereum">;
+        chainId: import("@trezor/schema-utils").TNumber;
+        network: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
     }>]>>;
-    definitions: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils").TObject<{
-        encoded_network: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer>;
-        encoded_token: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer>;
+    definitions: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+        encoded_network: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer>;
+        encoded_token: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer>;
     }>>;
 }>]>;
 export default class EthereumSignTypedData extends AbstractMethod<'ethereumSignTypedData', Params> {

package/lib/api/ethereum/api/ethereumSignTypedData.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const protobuf_1 = require("@trezor/protobuf");
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const pathUtils_1 = require("../../../utils/pathUtils");
@@ -11,8 +13,6 @@ const ethereumSignTypedData_1 = require("../ethereumSignTypedData");
 const formatUtils_1 = require("../../../utils/formatUtils");
 const ethereumDefinitions_1 = require("../ethereumDefinitions");
 const types_1 = require("../../../types");
-const protobuf_1 = require("@trezor/protobuf");
-const schema_utils_1 = require("@trezor/schema-utils");
 const Params = schema_utils_1.Type.Intersect([
     schema_utils_1.Type.Union([
         schema_utils_1.Type.Omit(ethereum_1.EthereumSignTypedData, schema_utils_1.Type.Literal('path')),
@@ -27,6 +27,7 @@ const Params = schema_utils_1.Type.Intersect([
 class EthereumSignTypedData extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
+        this.requiredDeviceCapabilities = ['Capability_Ethereum'];
         const { payload } = this;
         (0, schema_utils_1.Assert)(schema_utils_1.Type.Union([ethereum_1.EthereumSignTypedData, ethereum_1.EthereumSignTypedHash]), payload);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);

package/lib/api/ethereum/api/ethereumVerifyMessage.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const formatUtils_1 = require("../../../utils/formatUtils");
-const schema_utils_1 = require("@trezor/schema-utils");
 const types_1 = require("../../../types");
 class EthereumVerifyMessage extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        this.requiredDeviceCapabilities = ['Capability_Ethereum'];
         const { payload } = this;
         (0, schema_utils_1.Assert)(types_1.EthereumVerifyMessage, payload);
         const messageHex = payload.hex