@trezor/connect 9.0.7 → 9.0.8

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 9.0.8
+
+-   feat: support multiple intermediary FWs for model 1 and devkit binaries
+    -   `FirmwareUpdate` now accepts `intermediaryVersion` param instead of `intermediary`
+    -   `getInfo` returns `intermediaryVersion` needed for T1 and removed `latest` param. 'release' always return latest version for T1 so it means abandoning the concept of incremental updates for T1.
+-   feat: signTransaction now returns `signedTransaction` which can be used for visualization purposes before notification about pending transaction from blockchain is received.
+-   feat(blockchain): `blockchainGetCurrentFiatRates` and `blockchainGetFiatRatesForTimestamps` now accept additional `token` parameter
+-   feat: support coinjoin for model 1
+-   feat(transport): eth definitions
+-   feat(webextension): Ignore port events if it is not port created by current popup
+-   feat(cardano): allow external reward addresses in governance registrations
+-   refactor(connect): removing browser related code from @trezor/connect
+
 # 9.0.7
 
 -   feat(connect-ui): connect UI will now display a warning in case it was opened by an application listed in https://github.com/MetaMask/eth-phishing-detect (#7488)

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.0.7
+API version 9.0.8
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)

package/lib/api/bitcoin/createPendingTx.d.ts

@@ -0,0 +1,35 @@
+import { Transaction as BitcoinJsTransaction } from '@trezor/utxo-lib';
+import { PROTO } from '../../constants';
+import type { AccountAddresses, AccountUtxo } from '../../types';
+export declare const createPendingTransaction: (tx: BitcoinJsTransaction, { utxo, addresses, inputs, outputs, }: {
+    utxo: AccountUtxo[];
+    addresses: AccountAddresses;
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
+}) => {
+    txid: string;
+    hex: string;
+    blockHeight: number;
+    blockTime: number;
+    confirmations: number;
+    vsize: number;
+    size: number;
+    value: string;
+    valueIn: string;
+    fees: string;
+    vin: {
+        n: number;
+        txid: string;
+        vout: number;
+        isAddress: boolean;
+        addresses: string[];
+        value: string;
+    }[];
+    vout: {
+        n: number;
+        isAddress: boolean;
+        addresses: string[];
+        value: string;
+    }[];
+};
+//# sourceMappingURL=createPendingTx.d.ts.map

package/lib/api/bitcoin/createPendingTx.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPendingTransaction = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
+const pathUtils_1 = require("../../utils/pathUtils");
+const createPendingTransaction = (tx, { utxo, addresses, inputs, outputs, }) => {
+    const valueOut = outputs.reduce((sum, out) => (0, bignumber_js_1.default)(sum).plus(out.amount), new bignumber_js_1.default('0'));
+    const valueIn = inputs.reduce((sum, ins) => (0, bignumber_js_1.default)(sum).plus(ins.amount), new bignumber_js_1.default('0'));
+    return {
+        txid: tx.getId(),
+        hex: tx.toHex(),
+        blockHeight: 0,
+        blockTime: Math.floor(Date.now() / 1000),
+        confirmations: 0,
+        vsize: tx.virtualSize(),
+        size: tx.weight(),
+        value: valueOut.toString(),
+        valueIn: valueIn.toString(),
+        fees: valueIn.minus(valueOut).toString(),
+        vin: inputs.map((ins, n) => ({
+            n,
+            txid: ins.prev_hash,
+            vout: ins.prev_index,
+            isAddress: true,
+            addresses: utxo
+                .filter(utxo => utxo.txid === ins.prev_hash && utxo.vout === ins.prev_index)
+                .map(utxo => utxo.address),
+            value: ins.amount.toString(),
+        })),
+        vout: outputs.map((out, n) => {
+            let transformedAddresses = [];
+            if (out.address) {
+                transformedAddresses = [out.address];
+            }
+            else if ('op_return_data' in out) {
+                transformedAddresses = [
+                    `OP_RETURN (${Buffer.from(out.op_return_data, 'hex').toString('ascii')})`,
+                ];
+            }
+            else {
+                transformedAddresses = [
+                    ...addresses.change,
+                    ...addresses.unused,
+                    ...addresses.used,
+                ]
+                    .filter(address => out.address_n && address.path === (0, pathUtils_1.getSerializedPath)(out.address_n))
+                    .map(address => address.address);
+            }
+            return {
+                n,
+                isAddress: out.script_type !== 'PAYTOOPRETURN',
+                addresses: transformedAddresses,
+                value: out.amount.toString(),
+            };
+        }),
+    };
+};
+exports.createPendingTransaction = createPendingTransaction;
+//# sourceMappingURL=createPendingTx.js.map

package/lib/api/bitcoin/index.d.ts

@@ -1,3 +1,4 @@
+export * from './createPendingTx';
 export * from './enhanceSignTx';
 export * from './Fees';
 export * from './inputs';

package/lib/api/bitcoin/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./createPendingTx"), exports);
 tslib_1.__exportStar(require("./enhanceSignTx"), exports);
 tslib_1.__exportStar(require("./Fees"), exports);
 tslib_1.__exportStar(require("./inputs"), exports);

package/lib/api/blockchainGetAccountBalanceHistory.d.ts

@@ -6,7 +6,7 @@ type Params = {
 };
 export default class BlockchainGetAccountBalanceHistory extends AbstractMethod<'blockchainGetAccountBalanceHistory', Params> {
     init(): void;
-    run(): Promise<import("packages/blockchain-link/lib/types/common").AccountBalanceHistory[]>;
+    run(): Promise<import("packages/blockchain-link-types/lib/common").AccountBalanceHistory[]>;
 }
 export {};
 //# sourceMappingURL=blockchainGetAccountBalanceHistory.d.ts.map

package/lib/api/blockchainGetCurrentFiatRates.d.ts

@@ -3,12 +3,13 @@ import type { CoinInfo } from '../types';
 type Params = {
     coinInfo: CoinInfo;
     currencies: Payload<'blockchainGetCurrentFiatRates'>['currencies'];
+    token: Payload<'blockchainGetCurrentFiatRates'>['token'];
 };
 export default class BlockchainGetCurrentFiatRates extends AbstractMethod<'blockchainGetCurrentFiatRates', Params> {
     init(): void;
     run(): Promise<{
         ts: number;
-        rates: import("packages/blockchain-link/lib").FiatRates;
+        rates: import("packages/blockchain-link-types/lib/common").FiatRates;
     }>;
 }
 export {};

package/lib/api/blockchainGetCurrentFiatRates.js

@@ -12,6 +12,7 @@ class BlockchainGetCurrentFiatRates extends AbstractMethod_1.AbstractMethod {
         const { payload } = this;
         (0, paramsValidator_1.validateParams)(payload, [
             { name: 'currencies', type: 'array', required: false },
+            { name: 'token', type: 'string' },
             { name: 'coin', type: 'string', required: true },
         ]);
         const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
@@ -21,12 +22,16 @@ class BlockchainGetCurrentFiatRates extends AbstractMethod_1.AbstractMethod {
         (0, BlockchainLink_1.isBackendSupported)(coinInfo);
         this.params = {
             currencies: payload.currencies,
+            token: payload.token,
             coinInfo,
         };
     }
     async run() {
         const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
-        return backend.getCurrentFiatRates({ currencies: this.params.currencies });
+        return backend.getCurrentFiatRates({
+            currencies: this.params.currencies,
+            token: this.params.token,
+        });
     }
 }
 exports.default = BlockchainGetCurrentFiatRates;

package/lib/api/blockchainGetFiatRatesForTimestamps.d.ts

@@ -2,14 +2,16 @@ import { Payload, AbstractMethod } from '../core/AbstractMethod';
 import type { CoinInfo } from '../types';
 type Params = {
     coinInfo: CoinInfo;
+    currencies: Payload<'blockchainGetFiatRatesForTimestamps'>['currencies'];
     timestamps: Payload<'blockchainGetFiatRatesForTimestamps'>['timestamps'];
+    token: Payload<'blockchainGetFiatRatesForTimestamps'>['token'];
 };
 export default class BlockchainGetFiatRatesForTimestamps extends AbstractMethod<'blockchainGetFiatRatesForTimestamps', Params> {
     init(): void;
     run(): Promise<{
         tickers: {
             ts: number;
-            rates: import("packages/blockchain-link/lib").FiatRates;
+            rates: import("packages/blockchain-link-types/lib/common").FiatRates;
         }[];
     }>;
 }

package/lib/api/blockchainGetFiatRatesForTimestamps.js

@@ -11,7 +11,9 @@ class BlockchainGetFiatRatesForTimestamps extends AbstractMethod_1.AbstractMetho
         this.useUi = false;
         const { payload } = this;
         (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'currencies', type: 'array', required: false },
             { name: 'timestamps', type: 'array', required: true },
+            { name: 'token', type: 'string' },
             { name: 'coin', type: 'string', required: true },
         ]);
         const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
@@ -20,13 +22,19 @@ class BlockchainGetFiatRatesForTimestamps extends AbstractMethod_1.AbstractMetho
         }
         (0, BlockchainLink_1.isBackendSupported)(coinInfo);
         this.params = {
+            currencies: payload.currencies,
             timestamps: payload.timestamps,
+            token: payload.token,
             coinInfo,
         };
     }
     async run() {
         const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
-        return backend.getFiatRatesForTimestamps({ timestamps: this.params.timestamps });
+        return backend.getFiatRatesForTimestamps({
+            currencies: this.params.currencies,
+            timestamps: this.params.timestamps,
+            token: this.params.token,
+        });
     }
 }
 exports.default = BlockchainGetFiatRatesForTimestamps;

package/lib/api/blockchainGetTransactions.d.ts

@@ -6,7 +6,7 @@ type Params = {
 };
 export default class BlockchainGetTransactions extends AbstractMethod<'blockchainGetTransactions', Params> {
     init(): void;
-    run(): Promise<import("packages/blockchain-link/lib").TypedRawTransaction[]>;
+    run(): Promise<import("packages/blockchain-link-types/lib").TypedRawTransaction[]>;
 }
 export {};
 //# sourceMappingURL=blockchainGetTransactions.d.ts.map

package/lib/api/cardano/cardanoAuxiliaryData.js

@@ -7,37 +7,57 @@ const pathUtils_1 = require("../../utils/pathUtils");
 const constants_1 = require("../../constants");
 const MAX_DELEGATION_COUNT = 32;
 const transformDelegation = (delegation) => {
+    if (delegation.votingPublicKey) {
+        console.warn('Please use votePublicKey instead of votingPublicKey.');
+        delegation.votePublicKey = delegation.votingPublicKey;
+    }
     (0, paramsValidator_1.validateParams)(delegation, [
-        { name: 'votingPublicKey', type: 'string', required: true },
+        { name: 'votePublicKey', type: 'string', required: true },
         { name: 'weight', type: 'uint', required: true },
     ]);
     return {
-        voting_public_key: delegation.votingPublicKey,
+        vote_public_key: delegation.votePublicKey,
         weight: delegation.weight,
     };
 };
-const transformGovernanceRegistrationParameters = (governanceRegistrationParameters) => {
-    (0, paramsValidator_1.validateParams)(governanceRegistrationParameters, [
-        { name: 'votingPublicKey', type: 'string' },
+const transformCvoteRegistrationParameters = (cVoteRegistrationParameters) => {
+    if (cVoteRegistrationParameters.votingPublicKey) {
+        console.warn('Please use votePublicKey instead of votingPublicKey.');
+        cVoteRegistrationParameters.votePublicKey = cVoteRegistrationParameters.votingPublicKey;
+    }
+    if (cVoteRegistrationParameters.rewardAddressParameters) {
+        console.warn('Please use paymentAddressParameters instead of rewardAddressParameters.');
+        cVoteRegistrationParameters.paymentAddressParameters =
+            cVoteRegistrationParameters.rewardAddressParameters;
+    }
+    (0, paramsValidator_1.validateParams)(cVoteRegistrationParameters, [
+        { name: 'votePublicKey', type: 'string' },
         { name: 'stakingPath', required: true },
         { name: 'nonce', type: 'uint', required: true },
         { name: 'format', type: 'number' },
         { name: 'delegations', type: 'array', allowEmpty: true },
         { name: 'votingPurpose', type: 'uint' },
+        { name: 'address', type: 'string' },
     ]);
-    (0, cardanoAddressParameters_1.validateAddressParameters)(governanceRegistrationParameters.rewardAddressParameters);
-    const { delegations } = governanceRegistrationParameters;
+    const { paymentAddressParameters } = cVoteRegistrationParameters;
+    if (paymentAddressParameters) {
+        (0, cardanoAddressParameters_1.validateAddressParameters)(paymentAddressParameters);
+    }
+    const { delegations } = cVoteRegistrationParameters;
     if (delegations && delegations.length > MAX_DELEGATION_COUNT) {
-        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `At most ${MAX_DELEGATION_COUNT} delegations are allowed in a governance registration`);
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `At most ${MAX_DELEGATION_COUNT} delegations are allowed in a CIP-36 registration`);
     }
     return {
-        voting_public_key: governanceRegistrationParameters.votingPublicKey,
-        staking_path: (0, pathUtils_1.validatePath)(governanceRegistrationParameters.stakingPath, 3),
-        reward_address_parameters: (0, cardanoAddressParameters_1.addressParametersToProto)(governanceRegistrationParameters.rewardAddressParameters),
-        nonce: governanceRegistrationParameters.nonce,
-        format: governanceRegistrationParameters.format,
+        vote_public_key: cVoteRegistrationParameters.votePublicKey,
+        staking_path: (0, pathUtils_1.validatePath)(cVoteRegistrationParameters.stakingPath, 3),
+        payment_address_parameters: paymentAddressParameters
+            ? (0, cardanoAddressParameters_1.addressParametersToProto)(paymentAddressParameters)
+            : undefined,
+        nonce: cVoteRegistrationParameters.nonce,
+        format: cVoteRegistrationParameters.format,
         delegations: delegations === null || delegations === void 0 ? void 0 : delegations.map(transformDelegation),
-        voting_purpose: governanceRegistrationParameters.votingPurpose,
+        voting_purpose: cVoteRegistrationParameters.votingPurpose,
+        payment_address: cVoteRegistrationParameters.paymentAddress,
     };
 };
 const transformAuxiliaryData = (auxiliaryData) => {
@@ -47,24 +67,24 @@ const transformAuxiliaryData = (auxiliaryData) => {
             type: 'string',
         },
     ]);
-    let governanceRegistrationParameters;
-    if (auxiliaryData.governanceRegistrationParameters) {
-        governanceRegistrationParameters = transformGovernanceRegistrationParameters(auxiliaryData.governanceRegistrationParameters);
+    let cVoteRegistrationParameters;
+    if (auxiliaryData.cVoteRegistrationParameters) {
+        cVoteRegistrationParameters = transformCvoteRegistrationParameters(auxiliaryData.cVoteRegistrationParameters);
     }
     return {
         hash: auxiliaryData.hash,
-        governance_registration_parameters: governanceRegistrationParameters,
+        cvote_registration_parameters: cVoteRegistrationParameters,
     };
 };
 exports.transformAuxiliaryData = transformAuxiliaryData;
 const modifyAuxiliaryDataForBackwardsCompatibility = (device, auxiliary_data) => {
-    const { governance_registration_parameters } = auxiliary_data;
-    if (governance_registration_parameters) {
-        governance_registration_parameters.reward_address_parameters =
-            (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(device, governance_registration_parameters.reward_address_parameters);
+    const { cvote_registration_parameters } = auxiliary_data;
+    if (cvote_registration_parameters === null || cvote_registration_parameters === void 0 ? void 0 : cvote_registration_parameters.payment_address_parameters) {
+        cvote_registration_parameters.payment_address_parameters =
+            (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(device, cvote_registration_parameters.payment_address_parameters);
         return {
             ...auxiliary_data,
-            governance_registration_parameters,
+            cvote_registration_parameters,
         };
     }
     return auxiliary_data;

package/lib/api/cardanoSignTransaction.d.ts

@@ -15,7 +15,8 @@ declare const CardanoSignTransactionFeatures: Readonly<{
     Plutus: string[];
     KeyHashStakeCredential: string[];
     Babbage: string[];
-    GovernanceRegistrationCIP36: string[];
+    CIP36Registration: string[];
+    CIP36RegistrationExternalPaymentAddress: string[];
 }>;
 export type CardanoSignTransactionParams = {
     signingMode: PROTO.CardanoTxSigningMode;

package/lib/api/cardanoSignTransaction.js

@@ -21,7 +21,8 @@ const CardanoSignTransactionFeatures = Object.freeze({
     Plutus: ['0', '2.4.4'],
     KeyHashStakeCredential: ['0', '2.4.4'],
     Babbage: ['0', '2.5.2'],
-    GovernanceRegistrationCIP36: ['0', '2.5.3'],
+    CIP36Registration: ['0', '2.5.3'],
+    CIP36RegistrationExternalPaymentAddress: ['0', '2.5.4'],
 });
 class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
@@ -36,10 +37,15 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Auxiliary data can now only be sent as a hash.');
         }
         if (payload.auxiliaryData && payload.auxiliaryData.catalystRegistrationParameters) {
-            console.warn('Please use governanceRegistrationParameters instead of catalystRegistrationParameters.');
-            payload.auxiliaryData.governanceRegistrationParameters =
+            console.warn('Please use cVoteRegistrationParameters instead of catalystRegistrationParameters.');
+            payload.auxiliaryData.cVoteRegistrationParameters =
                 payload.auxiliaryData.catalystRegistrationParameters;
         }
+        if (payload.auxiliaryData && payload.auxiliaryData.governanceRegistrationParameters) {
+            console.warn('Please use cVoteRegistrationParameters instead of governanceRegistrationParameters.');
+            payload.auxiliaryData.cVoteRegistrationParameters =
+                payload.auxiliaryData.governanceRegistrationParameters;
+        }
         (0, paramsValidator_1.validateParams)(payload, [
             { name: 'signingMode', type: 'number', required: true },
             { name: 'inputs', type: 'array', required: true },
@@ -204,12 +210,15 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             params.signingMode !== constants_1.PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
             this._ensureFeatureIsSupported('Babbage');
         }
-        if ((_a = params.auxiliaryData) === null || _a === void 0 ? void 0 : _a.governance_registration_parameters) {
-            const { format, delegations, voting_purpose } = params.auxiliaryData.governance_registration_parameters;
-            if (format === constants_1.PROTO.CardanoGovernanceRegistrationFormat.CIP36 ||
+        if ((_a = params.auxiliaryData) === null || _a === void 0 ? void 0 : _a.cvote_registration_parameters) {
+            const { format, delegations, voting_purpose, payment_address } = params.auxiliaryData.cvote_registration_parameters;
+            if (format === constants_1.PROTO.CardanoCVoteRegistrationFormat.CIP36 ||
                 (delegations === null || delegations === void 0 ? void 0 : delegations.length) ||
                 voting_purpose != null) {
-                this._ensureFeatureIsSupported('GovernanceRegistrationCIP36');
+                this._ensureFeatureIsSupported('CIP36Registration');
+            }
+            if (payment_address) {
+                this._ensureFeatureIsSupported('CIP36RegistrationExternalPaymentAddress');
             }
         }
     }
@@ -261,8 +270,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         }
         let auxiliaryDataSupplement;
         if (this.params.auxiliaryData) {
-            const { governance_registration_parameters } = this.params.auxiliaryData;
-            if (governance_registration_parameters) {
+            const { cvote_registration_parameters } = this.params.auxiliaryData;
+            if (cvote_registration_parameters) {
                 this.params.auxiliaryData = (0, cardanoAuxiliaryData_1.modifyAuxiliaryDataForBackwardsCompatibility)(this.device, this.params.auxiliaryData);
             }
             const { message } = await typedCall('CardanoTxAuxiliaryData', 'CardanoTxAuxiliaryDataSupplement', this.params.auxiliaryData);
@@ -271,8 +280,9 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
                 auxiliaryDataSupplement = {
                     type: auxiliaryDataType,
                     auxiliaryDataHash: message.auxiliary_data_hash,
-                    governanceSignature: message.governance_signature,
-                    catalystSignature: message.governance_signature,
+                    cVoteRegistrationSignature: message.cvote_registration_signature,
+                    catalystSignature: message.cvote_registration_signature,
+                    governanceSignature: message.cvote_registration_signature,
                 };
             }
             await typedCall('CardanoTxHostAck', 'CardanoTxItemAck');

package/lib/api/composeTransaction.js

@@ -172,7 +172,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
         discovery.removeAllListeners();
         discovery.stop();
         if (!discovery.completed) {
-            await (0, promiseUtils_1.resolveAfter)(501);
+            await (0, promiseUtils_1.resolveAfter)(501).promise;
         }
         const account = discovery.accounts[uiResp.payload];
         this.params.coinInfo = (0, coinInfo_1.fixCoinInfoNetwork)(this.params.coinInfo, account.address_n);
@@ -195,7 +195,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
         const hasFunds = composer.composeAllFeeLevels();
         if (!hasFunds) {
             this.postMessage((0, events_1.createUiMessage)(events_1.UI.INSUFFICIENT_FUNDS));
-            await (0, promiseUtils_1.resolveAfter)(2000, null);
+            await (0, promiseUtils_1.resolveAfter)(2000, null).promise;
             return 'change-account';
         }
         this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_FEE, {

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

@@ -0,0 +1,7 @@
+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>;
+//# sourceMappingURL=ethereumDefinitions.d.ts.map

package/lib/api/ethereum/ethereumDefinitions.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEthereumDefinitions = void 0;
+const tslib_1 = require("tslib");
+const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+const getEthereumDefinitions = async ({ chainId, slip44, contractAddress, }) => {
+    const definitions = {};
+    if (!chainId && !slip44) {
+        throw new Error('argument chainId or slip44 is required');
+    }
+    try {
+        const networkDefinitionUrl = `https://data.trezor.io/firmware/eth-definitions/${chainId ? 'chain-id' : 'slip44'}/${chainId !== null && chainId !== void 0 ? chainId : slip44}/network.dat`;
+        const networkDefinition = await (0, cross_fetch_1.default)(networkDefinitionUrl);
+        if (networkDefinition.status === 200) {
+            definitions.encoded_network = await networkDefinition.arrayBuffer();
+        }
+        else if (networkDefinition.status !== 404) {
+            throw new Error(`unexpected status: $${networkDefinition.status}`);
+        }
+    }
+    catch (err) {
+        console.warn(`unable to download or parse ${chainId} definition. detail: ${err.message}`);
+    }
+    try {
+        if (contractAddress) {
+            const lowerCaseContractAddress = contractAddress.toLowerCase();
+            const tokenDefinitionUrl = `https://data.trezor.io/firmware/eth-definitions/${chainId ? 'chain-id' : 'slip44'}/${chainId !== null && chainId !== void 0 ? chainId : slip44}/token-${lowerCaseContractAddress}.dat`;
+            const tokenDefinition = await (0, cross_fetch_1.default)(tokenDefinitionUrl);
+            if (tokenDefinition.status === 200) {
+                definitions.encoded_token = await tokenDefinition.arrayBuffer();
+            }
+            else if (tokenDefinition.status !== 404) {
+                throw new Error(`unexpected status: $${tokenDefinition.status}`);
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`unable to download or parse ${chainId}/${contractAddress} definition. detail: ${err.message}`);
+    }
+    return definitions;
+};
+exports.getEthereumDefinitions = getEthereumDefinitions;
+//# sourceMappingURL=ethereumDefinitions.js.map

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

@@ -1,11 +1,12 @@
+import { EthereumDefinitions } from '@trezor/transport/lib/types/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) => Promise<{
+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<{
     v: string;
     r: string;
     s: string;
 }>;
-export declare const ethereumSignTxEIP1559: (typedCall: TypedCall, address_n: number[], to: string, value: string, gas_limit: string, max_gas_fee: string, max_priority_fee: string, nonce: string, chain_id: number, data?: string, access_list?: EthereumAccessList[]) => Promise<{
+export declare const ethereumSignTxEIP1559: (typedCall: TypedCall, address_n: number[], to: string, value: string, gas_limit: string, max_gas_fee: string, max_priority_fee: string, nonce: string, chain_id: number, data?: string, access_list?: EthereumAccessList[], definitions?: EthereumDefinitions) => Promise<{
     v: string;
     r: string;
     s: string;

package/lib/api/ethereum/ethereumSignTx.js

@@ -37,7 +37,7 @@ const stripLeadingZeroes = (str) => {
     }
     return str;
 };
-const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_price, nonce, chain_id, data, tx_type) => {
+const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_price, nonce, chain_id, data, tx_type, definitions) => {
     const length = data == null ? 0 : data.length / 2;
     const [first, rest] = splitString(data, 1024 * 2);
     let message = {
@@ -48,6 +48,7 @@ const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_pr
         gas_limit: stripLeadingZeroes(gas_limit),
         to,
         value: stripLeadingZeroes(value),
+        definitions,
     };
     if (length !== 0) {
         message = {
@@ -66,7 +67,7 @@ const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_pr
     return processTxRequest(typedCall, response.message, rest, chain_id);
 };
 exports.ethereumSignTx = ethereumSignTx;
-const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit, max_gas_fee, max_priority_fee, nonce, chain_id, data, access_list) => {
+const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit, max_gas_fee, max_priority_fee, nonce, chain_id, data, access_list, definitions) => {
     const length = data == null ? 0 : data.length / 2;
     const [first, rest] = splitString(data, 1024 * 2);
     const message = {
@@ -84,6 +85,7 @@ const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit,
             address: a.address,
             storage_keys: a.storageKeys,
         })),
+        definitions,
     };
     const response = await typedCall('EthereumSignTxEIP1559', 'EthereumTxRequest', message);
     return processTxRequest(typedCall, response.message, rest);

package/lib/api/ethereumGetAddress.d.ts

@@ -4,6 +4,7 @@ import type { EthereumNetworkInfo } from '../types';
 type Params = PROTO.EthereumGetAddress & {
     address?: string;
     network?: EthereumNetworkInfo;
+    encoded_network?: ArrayBuffer;
 };
 export default class EthereumGetAddress extends AbstractMethod<'ethereumGetAddress', Params[]> {
     hasBundle?: boolean;
@@ -17,7 +18,7 @@ export default class EthereumGetAddress extends AbstractMethod<'ethereumGetAddre
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_n, show_display }: Params): Promise<{
+    _call({ address_n, show_display, encoded_network }: Params): Promise<{
         path: number[];
         serializedPath: string;
         address: string;

package/lib/api/ethereumGetAddress.js

@@ -8,6 +8,7 @@ const coinInfo_1 = require("../data/coinInfo");
 const formatUtils_1 = require("../utils/formatUtils");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
+const ethereumDefinitions_1 = require("./ethereum/ethereumDefinitions");
 class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);
@@ -90,20 +91,33 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
         const uiResp = await uiPromise.promise;
         return uiResp.payload;
     }
-    _call({ address_n, show_display }) {
+    _call({ address_n, show_display, encoded_network }) {
         const cmd = this.device.getCommands();
         return cmd.ethereumGetAddress({
             address_n,
             show_display,
+            encoded_network,
         });
     }
     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') {
@@ -116,7 +130,10 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
                     batch.address = silent.address;
                 }
             }
-            const response = await this._call(batch);
+            const response = await this._call({
+                ...batch,
+                ...definitionParams,
+            });
             responses.push(response);
             if (this.hasBundle) {
                 this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {