@trezor/connect 9.1.1 → 9.1.3

package/lib/api/cardanoGetPublicKey.js

@@ -10,7 +10,6 @@ class CardanoGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
-        this.info = 'Export Cardano public key';
         this.hasBundle = !!this.payload.bundle;
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }
@@ -32,6 +31,9 @@ class CardanoGetPublicKey extends AbstractMethod_1.AbstractMethod {
             };
         });
     }
+    get info() {
+        return 'Export Cardano public key';
+    }
     async confirmation() {
         if (this.confirmed)
             return true;
@@ -56,7 +58,7 @@ class CardanoGetPublicKey extends AbstractMethod_1.AbstractMethod {
         await this.getPopupPromise().promise;
         const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
         this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
-            view: 'get-public-key-no-backup',
+            view: 'no-backup',
         }));
         const uiResp = await uiPromise.promise;
         return uiResp.payload;

package/lib/api/cardanoSignTransaction.d.ts

@@ -44,6 +44,7 @@ export type CardanoSignTransactionParams = {
 };
 export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignTransaction', CardanoSignTransactionParams> {
     init(): void;
+    get info(): string;
     _isFeatureSupported(feature: keyof typeof CardanoSignTransactionFeatures): boolean;
     _ensureFeatureIsSupported(feature: keyof typeof CardanoSignTransactionFeatures): void;
     _ensureFirmwareSupportsParams(): void;

package/lib/api/cardanoSignTransaction.js

@@ -28,7 +28,6 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
-        this.info = 'Sign Cardano transaction';
         const { payload } = this;
         if (payload.metadata) {
             throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Metadata field has been replaced by auxiliaryData.');
@@ -151,6 +150,9 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             includeNetworkId: payload.includeNetworkId,
         };
     }
+    get info() {
+        return 'Sign Cardano transaction';
+    }
     _isFeatureSupported(feature) {
         return this.device.atLeast(CardanoSignTransactionFeatures[feature]);
     }

package/lib/api/checkFirmwareAuthenticity.js

@@ -7,6 +7,7 @@ const firmware_1 = require("./firmware");
 const firmwareInfo_1 = require("../data/firmwareInfo");
 const constants_1 = require("../constants");
 const assets_1 = require("../utils/assets");
+const types_1 = require("../types");
 class CheckFirmwareAuthenticity extends AbstractMethod_1.AbstractMethod {
     init() {
         this.useEmptyPassphrase = true;
@@ -22,7 +23,7 @@ class CheckFirmwareAuthenticity extends AbstractMethod_1.AbstractMethod {
             throw constants_1.ERRORS.TypedError('Runtime', 'checkFirmwareAuthenticity: No release found for device firmware');
         }
         const baseUrl = `https://data.trezor.io/firmware/${device.features.major_version}`;
-        const fwUrl = `${baseUrl}/trezor-${deviceVersion}${device.firmwareType === 'bitcoin-only' ? '-bitcoinonly.bin' : '.bin'}`;
+        const fwUrl = `${baseUrl}/trezor-${deviceVersion}${device.firmwareType === types_1.FirmwareType.BitcoinOnly ? '-bitcoinonly.bin' : '.bin'}`;
         const fw = await (0, assets_1.httpRequest)(fwUrl, 'binary');
         if (!fw) {
             throw constants_1.ERRORS.TypedError('Runtime', 'checkFirmwareAuthenticity: firmware binary not found');

package/lib/api/cipherKeyValue.d.ts

@@ -3,6 +3,7 @@ import type { PROTO } from '../constants';
 export default class CipherKeyValue extends AbstractMethod<'cipherKeyValue', PROTO.CipherKeyValue[]> {
     hasBundle?: boolean;
     init(): void;
+    get info(): string;
     run(): Promise<PROTO.CipheredKeyValue | PROTO.CipheredKeyValue[]>;
 }
 //# sourceMappingURL=cipherKeyValue.d.ts.map

package/lib/api/cipherKeyValue.js

@@ -8,7 +8,6 @@ class CipherKeyValue extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
-        this.info = 'Cipher key value';
         this.hasBundle = !!this.payload.bundle;
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }
@@ -37,6 +36,9 @@ class CipherKeyValue extends AbstractMethod_1.AbstractMethod {
             };
         });
     }
+    get info() {
+        return 'Cipher key value';
+    }
     async run() {
         const responses = [];
         const cmd = this.device.getCommands();

package/lib/api/composeTransaction.d.ts

@@ -1,3 +1,4 @@
+import BigNumber from 'bignumber.js';
 import { AbstractMethod } from '../core/AbstractMethod';
 import { Discovery } from './common/Discovery';
 import { TransactionComposer } from './bitcoin';
@@ -14,10 +15,12 @@ type Params = {
     floorBaseFee?: PrecomposeParams['floorBaseFee'];
     sequence?: PrecomposeParams['sequence'];
     skipPermutation?: PrecomposeParams['skipPermutation'];
+    total: BigNumber;
 };
 export default class ComposeTransaction extends AbstractMethod<'composeTransaction', Params> {
     discovery?: Discovery;
     init(): void;
+    get info(): string;
     precompose(account: PrecomposeParams['account'], feeLevels: PrecomposeParams['feeLevels']): Promise<PrecomposedTransaction[]>;
     run(): Promise<SignedTransaction | PrecomposedTransaction[]>;
     selectAccount(): Promise<{

package/lib/api/composeTransaction.js

@@ -43,13 +43,6 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
             }
             outputs.push(output);
         });
-        const sendMax = outputs.find(o => o.type === 'send-max') !== undefined;
-        if (sendMax) {
-            this.info = 'Send maximum amount';
-        }
-        else {
-            this.info = `Send ${(0, formatUtils_1.formatAmount)(total.toString(), coinInfo)}`;
-        }
         this.useDevice = !payload.account && !payload.feeLevels;
         this.useUi = this.useDevice;
         this.params = {
@@ -62,8 +55,17 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
             sequence: payload.sequence,
             skipPermutation: payload.skipPermutation,
             push: typeof payload.push === 'boolean' ? payload.push : false,
+            total,
         };
     }
+    get info() {
+        var _a;
+        const sendMax = ((_a = this.params) === null || _a === void 0 ? void 0 : _a.outputs.find(o => o.type === 'send-max')) !== undefined;
+        if (sendMax) {
+            return 'Send maximum amount';
+        }
+        return `Send ${(0, formatUtils_1.formatAmount)(this.params.total.toString(), this.params.coinInfo)}`;
+    }
     async precompose(account, feeLevels) {
         const { coinInfo, outputs, baseFee, skipPermutation } = this.params;
         const address_n = pathUtils.validatePath(account.path);

package/lib/api/eosGetPublicKey.d.ts

@@ -4,6 +4,7 @@ export default class EosGetPublicKey extends AbstractMethod<'eosGetPublicKey', P
     hasBundle?: boolean;
     confirmed?: boolean;
     init(): void;
+    get info(): string;
     confirmation(): Promise<boolean>;
     run(): Promise<import("..").EosPublicKey | import("..").EosPublicKey[]>;
 }

package/lib/api/eosGetPublicKey.js

@@ -9,7 +9,6 @@ class EosGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
-        this.info = 'Export Eos public key';
         this.hasBundle = !!this.payload.bundle;
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }
@@ -27,6 +26,9 @@ class EosGetPublicKey extends AbstractMethod_1.AbstractMethod {
             };
         });
     }
+    get info() {
+        return 'Export Eos public key';
+    }
     async confirmation() {
         if (this.confirmed)
             return true;

package/lib/api/eosSignTransaction.d.ts

@@ -8,6 +8,7 @@ type Params = {
 };
 export default class EosSignTransaction extends AbstractMethod<'eosSignTransaction', Params> {
     init(): void;
+    get info(): string;
     run(): Promise<{
         signature: string;
     }>;

package/lib/api/eosSignTransaction.js

@@ -10,7 +10,6 @@ class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
-        this.info = 'Sign EOS transaction';
         const { payload } = this;
         (0, paramsValidator_1.validateParams)(payload, [
             { name: 'path', required: true },
@@ -25,6 +24,9 @@ class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
             ack,
         };
     }
+    get info() {
+        return 'Sign EOS transaction';
+    }
     async run() {
         const response = await helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.chain_id, this.params.header, this.params.ack);
         return {

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

@@ -1,7 +1,29 @@
-import { EthereumDefinitions } from '@trezor/transport/lib/types/messages';
-export declare const getEthereumDefinitions: ({ chainId, slip44, contractAddress, }: {
-    chainId: number | undefined;
-    slip44?: number | undefined;
-    contractAddress?: string | undefined;
-}) => Promise<EthereumDefinitions>;
+import { EthereumDefinitions } from '@trezor/protobuf/lib/messages';
+import { EthereumNetworkInfo } from '../../types';
+interface GetEthereumDefinitions {
+    chainId?: number;
+    slip44?: number;
+    contractAddress?: string;
+}
+export declare const getEthereumDefinitions: ({ chainId, slip44, contractAddress, }: GetEthereumDefinitions) => Promise<EthereumDefinitions>;
+export interface EthereumNetworkDefinitionDecoded {
+    chain_id: number;
+    name: string;
+    slip44: number;
+    symbol: string;
+}
+export interface EthereumTokenDefinitionDecoded {
+    address: string;
+    chain_id: number;
+    decimals: number;
+    name: string;
+    symbol: string;
+}
+export interface EthereumDefinitionDecoded {
+    network?: EthereumNetworkDefinitionDecoded;
+    token?: EthereumTokenDefinitionDecoded;
+}
+export declare const decodeEthereumDefinition: (encodedDefinition: EthereumDefinitions) => EthereumDefinitionDecoded;
+export declare const ethereumNetworkInfoFromDefinition: (definition: EthereumNetworkDefinitionDecoded) => EthereumNetworkInfo;
+export {};
 //# sourceMappingURL=ethereumDefinitions.d.ts.map

package/lib/api/ethereum/ethereumDefinitions.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEthereumDefinitions = void 0;
+exports.ethereumNetworkInfoFromDefinition = exports.decodeEthereumDefinition = exports.getEthereumDefinitions = void 0;
 const tslib_1 = require("tslib");
 const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+const protocol_1 = require("@trezor/protocol");
+const protobuf_1 = require("@trezor/protobuf");
+const DataManager_1 = require("../../data/DataManager");
+const paramsValidator_1 = require("../common/paramsValidator");
+const coinInfo_1 = require("../../data/coinInfo");
 const getEthereumDefinitions = async ({ chainId, slip44, contractAddress, }) => {
     const definitions = {};
     if (!chainId && !slip44) {
@@ -40,4 +45,58 @@ const getEthereumDefinitions = async ({ chainId, slip44, contractAddress, }) =>
     return definitions;
 };
 exports.getEthereumDefinitions = getEthereumDefinitions;
+const decodeEthereumDefinition = (encodedDefinition) => {
+    const decoded = {
+        network: undefined,
+        token: undefined,
+    };
+    ['encoded_token', 'encoded_network'].forEach(key => {
+        const encodedPayload = encodedDefinition[key];
+        if (!encodedPayload) {
+            return;
+        }
+        const { definitionType, protobufPayload } = protocol_1.trzd.decode(encodedPayload);
+        const messages = DataManager_1.DataManager.getProtobufMessages();
+        const proto = (0, protobuf_1.parseConfigure)(messages);
+        const type = definitionType === 0 ? 'EthereumNetworkInfo' : 'EthereumTokenInfo';
+        const Message = proto.lookupType(type);
+        const decodedDefinition = (0, protobuf_1.decode)(Message, protobufPayload);
+        if (key === 'encoded_network') {
+            (0, paramsValidator_1.validateParams)(decodedDefinition, [
+                { name: 'chain_id', type: 'number', required: true },
+                { name: 'name', type: 'string', required: true },
+                { name: 'slip44', type: 'number', required: true },
+                { name: 'symbol', type: 'string', required: true },
+            ]);
+            decoded.network = decodedDefinition;
+        }
+        else if (key === 'encoded_token') {
+            (0, paramsValidator_1.validateParams)(decodedDefinition, [
+                { name: 'address', type: 'string', required: true },
+                { name: 'chain_id', type: 'number', required: true },
+                { name: 'name', type: 'string', required: true },
+                { name: 'decimals', type: 'number', required: true },
+                { name: 'symbol', type: 'string', required: true },
+            ]);
+            decoded.token = decodedDefinition;
+        }
+    });
+    return decoded;
+};
+exports.decodeEthereumDefinition = decodeEthereumDefinition;
+const ethereumNetworkInfoFromDefinition = (definition) => ({
+    ...coinInfo_1.ethereumNetworkInfoBase,
+    chainId: definition.chain_id,
+    label: definition.name,
+    name: definition.name,
+    slip44: definition.slip44,
+    shortcut: definition.symbol,
+    support: {
+        connect: true,
+        trezor1: '1.6.2',
+        trezor2: '2.0.7',
+    },
+    blockchainLink: undefined,
+});
+exports.ethereumNetworkInfoFromDefinition = ethereumNetworkInfoFromDefinition;
 //# sourceMappingURL=ethereumDefinitions.js.map

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

@@ -1,4 +1,4 @@
-import { EthereumDefinitions } from '@trezor/transport/lib/types/messages';
+import { EthereumDefinitions } from '@trezor/protobuf/lib/messages';
 import type { TypedCall } from '../../device/DeviceCommands';
 import type { EthereumAccessList } from '../../types/api/ethereum';
 export declare const ethereumSignTx: (typedCall: TypedCall, address_n: number[], to: string, value: string, gas_limit: string, gas_price: string, nonce: string, chain_id: number, data?: string, tx_type?: number, definitions?: EthereumDefinitions) => Promise<{

package/lib/api/ethereumGetAddress.d.ts

@@ -11,6 +11,8 @@ export default class EthereumGetAddress extends AbstractMethod<'ethereumGetAddre
     progress: number;
     confirmed?: boolean;
     init(): void;
+    initAsync(): Promise<void>;
+    get info(): string;
     getButtonRequestData(code: string): {
         type: "address";
         serializedPath: string;

package/lib/api/ethereumGetAddress.js

@@ -40,19 +40,6 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
                 network,
             };
         });
-        if (this.params.length === 1) {
-            this.info = (0, ethereumUtils_1.getNetworkLabel)('Export #NETWORK address', this.params[0].network);
-        }
-        else {
-            const requestedNetworks = this.params.map(b => b.network);
-            const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
-            if (uniqNetworks.length === 1 && uniqNetworks[0]) {
-                this.info = (0, ethereumUtils_1.getNetworkLabel)('Export multiple #NETWORK addresses', uniqNetworks[0]);
-            }
-            else {
-                this.info = 'Export multiple addresses';
-            }
-        }
         const useEventListener = payload.useEventListener &&
             this.params.length === 1 &&
             typeof this.params[0].address === 'string' &&
@@ -60,6 +47,34 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
         this.confirmed = useEventListener;
         this.useUi = !useEventListener;
     }
+    async initAsync() {
+        for (let i = 0; i < this.params.length; i++) {
+            if (!this.params[i].network) {
+                const slip44 = (0, pathUtils_1.getSlip44ByPath)(this.params[i].address_n);
+                const definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
+                    slip44,
+                });
+                const decoded = (0, ethereumDefinitions_1.decodeEthereumDefinition)(definitions);
+                if (decoded.network) {
+                    this.params[i].network = (0, ethereumDefinitions_1.ethereumNetworkInfoFromDefinition)(decoded.network);
+                }
+                if (definitions.encoded_network) {
+                    this.params[i].encoded_network = definitions.encoded_network;
+                }
+            }
+        }
+    }
+    get info() {
+        if (this.params.length === 1) {
+            return (0, ethereumUtils_1.getNetworkLabel)('Export #NETWORK address', this.params[0].network);
+        }
+        const requestedNetworks = this.params.map(b => b.network);
+        const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
+        if (uniqNetworks.length === 1 && uniqNetworks[0]) {
+            return (0, ethereumUtils_1.getNetworkLabel)('Export multiple #NETWORK addresses', uniqNetworks[0]);
+        }
+        return 'Export multiple addresses';
+    }
     getButtonRequestData(code) {
         if (code === 'ButtonRequest_Address') {
             return {
@@ -100,24 +115,12 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
         });
     }
     async run() {
-        var _a;
         const responses = [];
         for (let i = 0; i < this.params.length; i++) {
             const batch = this.params[i];
-            const slip44 = (0, pathUtils_1.getSlip44ByPath)(batch.address_n);
-            const definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
-                chainId: (_a = batch === null || batch === void 0 ? void 0 : batch.network) === null || _a === void 0 ? void 0 : _a.chainId,
-                slip44,
-            });
-            const definitionParams = {
-                ...(definitions.encoded_network && {
-                    encoded_network: definitions.encoded_network,
-                }),
-            };
             if (batch.show_display) {
                 const silent = await this._call({
                     ...batch,
-                    ...definitionParams,
                     show_display: false,
                 });
                 if (typeof batch.address === 'string') {
@@ -132,7 +135,6 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
             }
             const response = await this._call({
                 ...batch,
-                ...definitionParams,
             });
             responses.push(response);
             if (this.hasBundle) {

package/lib/api/ethereumGetPublicKey.d.ts

@@ -8,6 +8,7 @@ export default class EthereumGetPublicKey extends AbstractMethod<'ethereumGetPub
     hasBundle?: boolean;
     confirmed?: boolean;
     init(): void;
+    get info(): string;
     confirmation(): Promise<boolean>;
     run(): Promise<import("../types/api/getPublicKey").HDNodeResponse | import("../types/api/getPublicKey").HDNodeResponse[]>;
 }

package/lib/api/ethereumGetPublicKey.js

@@ -28,19 +28,17 @@ class EthereumGetPublicKey extends AbstractMethod_1.AbstractMethod {
                 network,
             };
         });
+    }
+    get info() {
         if (this.params.length === 1) {
-            this.info = (0, ethereumUtils_1.getNetworkLabel)('Export #NETWORK public key', this.params[0].network);
+            return (0, ethereumUtils_1.getNetworkLabel)('Export #NETWORK public key', this.params[0].network);
         }
-        else {
-            const requestedNetworks = this.params.map(b => b.network);
-            const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
-            if (uniqNetworks.length === 1 && uniqNetworks[0]) {
-                this.info = (0, ethereumUtils_1.getNetworkLabel)('Export multiple #NETWORK public keys', uniqNetworks[0]);
-            }
-            else {
-                this.info = 'Export multiple public keys';
-            }
+        const requestedNetworks = this.params.map(b => b.network);
+        const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
+        if (uniqNetworks.length === 1 && uniqNetworks[0]) {
+            return (0, ethereumUtils_1.getNetworkLabel)('Export multiple #NETWORK public keys', uniqNetworks[0]);
         }
+        return 'Export multiple public keys';
     }
     async confirmation() {
         if (this.confirmed)

package/lib/api/ethereumSignMessage.d.ts

@@ -1,7 +1,16 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 import type { PROTO } from '../constants';
-export default class EthereumSignMessage extends AbstractMethod<'ethereumSignMessage', PROTO.EthereumSignMessage> {
+import type { EthereumNetworkInfo } from '../types';
+import type { EthereumDefinitions } from '@trezor/protobuf/lib/messages';
+type Params = PROTO.EthereumSignMessage & {
+    network?: EthereumNetworkInfo;
+    definitions?: EthereumDefinitions;
+};
+export default class EthereumSignMessage extends AbstractMethod<'ethereumSignMessage', Params> {
     init(): void;
+    initAsync(): Promise<void>;
+    get info(): string;
     run(): Promise<PROTO.EthereumMessageSignature>;
 }
+export {};
 //# sourceMappingURL=ethereumSignMessage.d.ts.map

package/lib/api/ethereumSignMessage.js

@@ -19,7 +19,6 @@ class EthereumSignMessage extends AbstractMethod_1.AbstractMethod {
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);
         const network = (0, coinInfo_1.getEthereumNetwork)(path);
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);
-        this.info = (0, ethereumUtils_1.getNetworkLabel)('Sign #NETWORK message', network);
         const messageHex = payload.hex
             ? (0, formatUtils_1.messageToHex)(payload.message)
             : Buffer.from(payload.message, 'utf8').toString('hex');
@@ -28,22 +27,24 @@ class EthereumSignMessage extends AbstractMethod_1.AbstractMethod {
             message: messageHex,
         };
     }
-    async run() {
-        const cmd = this.device.getCommands();
-        const { address_n, message } = this.params;
-        const network = (0, coinInfo_1.getEthereumNetwork)(address_n);
+    async initAsync() {
+        if (this.params.network)
+            return;
+        const { address_n } = this.params;
         const slip44 = (0, pathUtils_1.getSlip44ByPath)(address_n);
-        const definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
-            chainId: network === null || network === void 0 ? void 0 : network.chainId,
+        this.params.definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
             slip44,
         });
-        const definitionParams = {
-            ...(definitions.encoded_network && {
-                encoded_network: definitions.encoded_network,
-            }),
-        };
+    }
+    get info() {
+        return (0, ethereumUtils_1.getNetworkLabel)('Sign #NETWORK message', (0, coinInfo_1.getEthereumNetwork)(this.params.address_n));
+    }
+    async run() {
+        var _a;
+        const cmd = this.device.getCommands();
+        const { address_n, message } = this.params;
         const response = await cmd.typedCall('EthereumSignMessage', 'EthereumMessageSignature', {
-            ...definitionParams,
+            encoded_network: (_a = this.params.definitions) === null || _a === void 0 ? void 0 : _a.encoded_network,
             address_n,
             message,
         });

package/lib/api/ethereumSignTransaction.d.ts

@@ -1,5 +1,7 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 import type { EthereumTransaction, EthereumTransactionEIP1559 } from '../types/api/ethereum';
+import type { EthereumNetworkInfo } from '../types';
+import type { EthereumDefinitions } from '@trezor/protobuf/lib/messages';
 type Params = {
     path: number[];
     tx: ({
@@ -7,9 +9,13 @@ type Params = {
     } & EthereumTransaction) | ({
         type: 'eip1559';
     } & EthereumTransactionEIP1559);
+    network?: EthereumNetworkInfo;
+    definitions?: EthereumDefinitions;
 };
 export default class EthereumSignTransaction extends AbstractMethod<'ethereumSignTransaction', Params> {
     init(): void;
+    initAsync(): Promise<void>;
+    get info(): string;
     run(): Promise<{
         v: string;
         r: string;

package/lib/api/ethereumSignTransaction.js

@@ -35,7 +35,6 @@ class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
         ]);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);
         const network = (0, coinInfo_1.getEthereumNetwork)(path);
-        this.info = (0, ethereumUtils_1.getNetworkLabel)('Sign #NETWORK transaction', network);
         const tx = payload.transaction;
         const isEIP1559 = tx.maxFeePerGas && tx.maxPriorityFeePerGas;
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(isEIP1559 ? 'eip1559' : this.name, network, this.firmwareRange);
@@ -70,16 +69,30 @@ class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
                 type: isEIP1559 ? 'eip1559' : 'legacy',
                 ...strip(tx),
             },
+            network,
         };
     }
-    async run() {
-        const { tx } = this.params;
+    async initAsync() {
+        if (this.params.tx.chainId === 1 && !this.params.tx.data) {
+            return;
+        }
         const slip44 = (0, pathUtils_1.getSlip44ByPath)(this.params.path);
         const definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
-            chainId: tx.chainId,
+            chainId: this.params.tx.chainId,
             slip44,
-            contractAddress: tx.data ? tx.to : undefined,
+            contractAddress: this.params.tx.data ? this.params.tx.to : undefined,
         });
+        this.params.definitions = definitions;
+        const decoded = (0, ethereumDefinitions_1.decodeEthereumDefinition)(definitions);
+        if (decoded.network) {
+            this.params.network = (0, ethereumDefinitions_1.ethereumNetworkInfoFromDefinition)(decoded.network);
+        }
+    }
+    get info() {
+        return (0, ethereumUtils_1.getNetworkLabel)('Sign #NETWORK transaction', this.params.network);
+    }
+    run() {
+        const { tx, definitions } = this.params;
         return tx.type === 'eip1559'
             ? 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, tx.data, tx.accessList, definitions)
             : 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, tx.data, tx.txType, definitions);

package/lib/api/ethereumSignTypedData.d.ts

@@ -1,10 +1,16 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 import type { EthereumSignTypedDataTypes, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '../types/api/ethereum';
+import type { EthereumNetworkInfo } from '../types';
+import type { EthereumDefinitions } from '@trezor/protobuf/lib/messages';
 type Params = (Omit<EthereumSignTypedDataParams<EthereumSignTypedDataTypes>, 'path'> | Omit<EthereumSignTypedHashParams<EthereumSignTypedDataTypes>, 'path'>) & {
     address_n: number[];
+    network?: EthereumNetworkInfo;
+    definitions?: EthereumDefinitions;
 };
 export default class EthereumSignTypedData extends AbstractMethod<'ethereumSignTypedData', Params> {
     init(): void;
+    initAsync(): Promise<void>;
+    get info(): string;
     run(): Promise<{
         address: string;
         signature: string;