@trezor/connect 9.5.3-beta.1 → 9.5.4-beta.1

package/CHANGELOG.md

@@ -1,17 +1,51 @@
 |             Package              | Stable |    Canary    |
 | :------------------------------: | :----: | :----------: |
-|       npm @trezor/connect        | 9.5.2  | 9.5.3-beta.1 |
-|     npm @trezor/connect-web      | 9.5.2  | 9.5.3-beta.1 |
-| npm @trezor/connect-webextension | 9.5.2  | 9.5.3-beta.1 |
+|       npm @trezor/connect        | 9.5.3  | 9.5.4-beta.1 |
+|     npm @trezor/connect-web      | 9.5.3  | 9.5.4-beta.1 |
+| npm @trezor/connect-webextension | 9.5.3  | 9.5.4-beta.1 |
 |    npm @trezor/connect-mobile    |   -    | 0.0.1-beta.1 |
 
 |     Deployment     | Stable |    Canary    |
 | :----------------: | :----: | :----------: |
-| connect.trezor.io/ | 9.5.2  | 9.5.3-beta.1 |
+| connect.trezor.io/ | 9.5.3  | 9.5.4-beta.1 |
 
 Use the persistent link [connect.trezor.io/9](https://connect.trezor.io/9/) to access the latest stable version of Connect Explorer.
 
-# 9.5.3-beta.1
+# 9.5.4-beta.1
+
+If you are using @trezor/connect-web you must be using at least 9.1.5 starting from this release.
+
+## Features
+
+-   add descriptor to getPublicKey response (cbfec9b)
+-   implement EVM EIP-1559 fees for ethereum in blockchainEstimateFee method (0475047)
+-   improvements in @trezor/connect-web package regarding support of calling @trezor/connect inside suite-desktop application. always attempt reconnection for core in desktop (21da232); implement @trezor/websocket client in core-in-suite-desktop (9744c5b); error fallback for core in desktop (64cbd47)
+
+## Fixes
+
+-   fixing session releasing on page unload (6d01d78)
+-   fixing missing session owner in device object (e2116c1)
+-   turn off language update during fw update for T3T1 since it does not fit device memory (283d829)
+
+## Chores
+
+-   migrate ripple-lib to xrpl.js (422c175)
+-   reuse PublicKey type in HDNodeResponse type definition (6c841d9)
+-   update device authenticity config (bf82b92)
+-   connect core refactoring (1d62c9b 19b6e5e 0dd2933 f9998f3 7dc1290 b685518 fb14734)
+-   pass full request object parameter in blockchainEstimateFee method down to @trezor/blockchain-link to allow more fine-grained backend calls (19c5952)
+-   refactoring in visual components (00e7df5, b3a4791)
+
+## Deps
+
+-   update next-seo from 6.0.0 to 6.6.0 (b5a818e)
+-   update swr from 2.2.5 to 2.3.3 (6d98da6)
+-   update remark-gfm from 4.0.0 to 4.0.1 (21a8f89)
+-   update zod from 3.23.8 to 3.24.2 (afc3d9b)
+-   update ua-parser-js@2.0.3 (840d5c6)
+-   upgrade next js for connect explorer theme (951e047)
+
+# 9.5.3
 
 ## Fixes
 

package/README.md

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

package/lib/api/binance/api/binanceSignTransaction.js

@@ -27,7 +27,7 @@ class BinanceSignTransaction extends AbstractMethod_1.AbstractMethod {
         return 'Sign Binance transaction';
     }
     run() {
-        return helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.transaction, this.params.chunkify);
+        return helper.signTx(this.device.getCommands().typedCall, this.params.path, this.params.transaction, this.params.chunkify);
     }
 }
 exports.default = BinanceSignTransaction;

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

@@ -8,17 +8,15 @@ export declare class BitcoinFeeLevels {
     blocks: Blocks;
     constructor(coinInfo: BitcoinNetworkInfo);
     load(blockchain: Blockchain): Promise<{
+        feePerTx?: string | undefined;
+        feeLimit?: string | undefined;
+        baseFeePerGas?: string | undefined;
         maxFeePerGas?: string | undefined;
         maxPriorityFeePerGas?: string | undefined;
         maxWaitTimeEstimate?: number | undefined;
-        minWaitTimeEstimate?: number | undefined;
-        feeLimit?: string | undefined;
-        feePerTx?: string | undefined;
-        baseFeePerGas?: string | undefined;
-        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
-        feePerUnit: string;
         blocks: number;
+        feePerUnit: string;
     }[]>;
     updateBitcoinCustomFee(feePerUnit: string): void;
 }

package/lib/api/bitcoin/BitcoinFees.js

@@ -2,7 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitcoinFeeLevels = void 0;
 const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
-const MiscFees_1 = require("../common/MiscFees");
+const findBlocksForFee = (feePerUnit, blocks) => {
+    const fee = new bigNumber_1.BigNumber(feePerUnit);
+    const lower = blocks.find(block => typeof block === 'string' && fee.gte(block));
+    if (!lower)
+        return -1;
+    return blocks.indexOf(lower);
+};
 const convertFeeRate = (fee, minFee) => {
     const feePerKB = new bigNumber_1.BigNumber(fee);
     if (feePerKB.isNaN() || feePerKB.lte('0'))
@@ -86,7 +92,7 @@ class BitcoinFeeLevels {
     }
     updateBitcoinCustomFee(feePerUnit) {
         this.levels = this.levels.filter(l => l.label !== 'custom');
-        const blocks = (0, MiscFees_1.findBlocksForFee)(feePerUnit, this.blocks);
+        const blocks = findBlocksForFee(feePerUnit, this.blocks);
         this.levels.push({
             label: 'custom',
             feePerUnit,

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

@@ -1,7 +1,7 @@
 import { PROTO } from '../../constants';
 import type { DeviceCommands } from '../../device/DeviceCommands';
 import type { BitcoinNetworkInfo } from '../../types';
-type GetHDNode = DeviceCommands['getHDNode'];
+type GetHDNode = ReturnType<typeof DeviceCommands>['getHDNode'];
 export declare const verifyTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo, unlockPath?: PROTO.UnlockPath) => Promise<import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/dash").DashSpecific> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/zcash").ZcashSpecific>>;
 export declare const verifyTicketTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo) => Promise<void>;
 export {};

package/lib/api/bitcoin/signtxVerify.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyTicketTx = exports.verifyTx = void 0;
 const utxo_lib_1 = require("@trezor/utxo-lib");
 const constants_1 = require("../../constants");
-const derivePubKeyHash = async (address_n, getHDNode, coinInfo, unlockPath) => {
+const derivePubKeyHash = async (getHDNode, address_n, coinInfo, unlockPath) => {
     if (address_n.length === 5) {
         const response = await getHDNode({ address_n: address_n.slice(0, 4) }, { coinInfo, unlockPath });
         const node = utxo_lib_1.bip32.fromBase58(response.xpub, coinInfo.network);
@@ -25,7 +25,7 @@ const deriveOutputScript = async (getHDNode, output, coinInfo, unlockPath) => {
     if (!output.address_n) {
         throw constants_1.ERRORS.TypedError('Runtime', 'deriveOutputScript: Neither address or address_n is set');
     }
-    const node = await derivePubKeyHash(output.address_n, getHDNode, coinInfo, unlockPath);
+    const node = await derivePubKeyHash(getHDNode, output.address_n, coinInfo, unlockPath);
     const payment = { hash: node.identifier, network: coinInfo.network };
     if (output.script_type === 'PAYTOADDRESS') {
         return utxo_lib_1.payments.p2pkh(payment).output;
@@ -105,7 +105,7 @@ const verifyTicketTx = async (getHDNode, inputs, outputs, serializedTx, coinInfo
             if (!output.address_n) {
                 throw constants_1.ERRORS.TypedError('Runtime', `verifyTicketTx: Output 1 should have address_n.`);
             }
-            const node = await derivePubKeyHash(output.address_n, getHDNode, coinInfo);
+            const node = await derivePubKeyHash(getHDNode, output.address_n, coinInfo);
             scriptA = utxo_lib_1.payments.sstxcommitment({
                 hash: node.identifier,
                 amount: output.amount.toString(),

package/lib/api/blockchainEstimateFee.js

@@ -8,6 +8,16 @@ const coinInfo_1 = require("../data/coinInfo");
 const BitcoinFees_1 = require("./bitcoin/BitcoinFees");
 const MiscFees_1 = require("./common/MiscFees");
 const EthereumFees_1 = require("./ethereum/EthereumFees");
+const getFees = (coinInfo) => {
+    switch (coinInfo.type) {
+        case 'bitcoin':
+            return new BitcoinFees_1.BitcoinFeeLevels(coinInfo);
+        case 'ethereum':
+            return new EthereumFees_1.EthereumFeeLevels(coinInfo);
+        default:
+            return new MiscFees_1.MiscFeeLevels(coinInfo);
+    }
+};
 class BlockchainEstimateFee extends AbstractMethod_1.AbstractMethod {
     init() {
         this.useDevice = false;
@@ -56,21 +66,11 @@ class BlockchainEstimateFee extends AbstractMethod_1.AbstractMethod {
             dustLimit: coinInfo.type === 'bitcoin' ? coinInfo.dustLimit : undefined,
             levels: [],
         };
-        const getFees = () => {
-            switch (coinInfo.type) {
-                case 'bitcoin':
-                    return new BitcoinFees_1.BitcoinFeeLevels(coinInfo);
-                case 'ethereum':
-                    return new EthereumFees_1.EthereumFeeLevels(coinInfo);
-                default:
-                    return new MiscFees_1.MiscFeeLevels(coinInfo);
-            }
-        };
-        if (request && request.feeLevels) {
-            const fees = getFees();
+        if (request?.feeLevels) {
+            const fees = getFees(coinInfo);
             if (request.feeLevels === 'smart') {
                 const backend = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, identity);
-                await fees.load(backend);
+                await fees.load(backend, request);
             }
             feeInfo.levels = fees.levels;
         }

package/lib/api/cardano/api/cardanoSignTransaction.js

@@ -143,7 +143,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         }
     }
     async _sign_tx() {
-        const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+        const { typedCall } = this.device.getCommands();
         const hasAuxiliaryData = !!this.params.auxiliaryData;
         const signTxInitMessage = {
             signing_mode: this.params.signingMode,

package/lib/api/common/Discovery.d.ts

@@ -1,18 +1,18 @@
 import EventEmitter from 'events';
 import { Blockchain } from '../../backend/BlockchainLink';
 import { PROTO } from '../../constants';
-import { DeviceCommands } from '../../device/DeviceCommands';
+import type { DeviceCommands } from '../../device/DeviceCommands';
 import type { CoinInfo, DiscoveryAccount, DiscoveryAccountType } from '../../types';
 import type { GetAccountInfo } from '../../types/api/getAccountInfo';
 type DiscoveryType = {
     type: DiscoveryAccountType;
     getPath: (index: number) => number[];
 };
+type GetDescriptor = (path: number[]) => ReturnType<ReturnType<typeof DeviceCommands>['getAccountDescriptor']>;
 type DiscoveryOptions = {
     blockchain: Blockchain;
-    commands: DeviceCommands;
+    getDescriptor: GetDescriptor;
     limit?: number;
-    derivationType?: PROTO.CardanoDerivationType;
 };
 export declare class Discovery extends EventEmitter {
     types: DiscoveryType[];
@@ -20,7 +20,7 @@ export declare class Discovery extends EventEmitter {
     accounts: DiscoveryAccount[];
     coinInfo: CoinInfo;
     blockchain: Blockchain;
-    commands: DeviceCommands;
+    getDescriptor: GetDescriptor;
     index: number;
     interrupted: boolean;
     completed: boolean;

package/lib/api/common/Discovery.js

@@ -12,7 +12,7 @@ class Discovery extends events_1.default {
     accounts;
     coinInfo;
     blockchain;
-    commands;
+    getDescriptor;
     index;
     interrupted;
     completed;
@@ -25,9 +25,8 @@ class Discovery extends events_1.default {
         this.interrupted = false;
         this.completed = false;
         this.blockchain = options.blockchain;
-        this.commands = options.commands;
         this.coinInfo = options.blockchain.coinInfo;
-        this.derivationType = options.derivationType;
+        this.getDescriptor = options.getDescriptor;
         const { coinInfo } = this;
         if (coinInfo.type === 'bitcoin') {
             const getDescriptor = (purpose, index) => (0, accountUtils_1.getAccountAddressN)(coinInfo, index, { purpose });
@@ -69,7 +68,7 @@ class Discovery extends events_1.default {
             const label = `Account #${this.index + 1}`;
             const overTheLimit = this.index >= limit;
             const path = accountType.getPath(this.index);
-            const descriptor = await this.commands.getAccountDescriptor(this.coinInfo, path, this.derivationType);
+            const descriptor = await this.getDescriptor(path);
             if (!descriptor) {
                 throw constants_1.ERRORS.TypedError('Runtime', 'Discovery: descriptor not found');
             }

package/lib/api/common/MiscFees.d.ts

@@ -1,26 +1,22 @@
 import { Blockchain } from '../../backend/BlockchainLink';
 import type { CoinInfo, FeeLevel } from '../../types';
 export type Blocks = Array<string | undefined>;
-export declare const findBlocksForFee: (feePerUnit: string, blocks: Blocks) => number;
 export declare class MiscFeeLevels {
     coinInfo: CoinInfo;
     levels: FeeLevel[];
     longTermFeeRate?: string;
     blocks: Blocks;
     constructor(coinInfo: CoinInfo);
-    load(blockchain: Blockchain): Promise<{
+    load(blockchain: Blockchain, request: Parameters<typeof blockchain.estimateFee>[0]): Promise<{
+        feePerTx?: string | undefined;
+        feeLimit?: string | undefined;
+        baseFeePerGas?: string | undefined;
         maxFeePerGas?: string | undefined;
         maxPriorityFeePerGas?: string | undefined;
         maxWaitTimeEstimate?: number | undefined;
-        minWaitTimeEstimate?: number | undefined;
-        feeLimit?: string | undefined;
-        feePerTx?: string | undefined;
-        baseFeePerGas?: string | undefined;
-        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
-        feePerUnit: string;
         blocks: number;
+        feePerUnit: string;
     }[]>;
-    updateCustomFee(feePerUnit: string): void;
 }
 //# sourceMappingURL=MiscFees.d.ts.map

package/lib/api/common/MiscFees.js

@@ -1,15 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiscFeeLevels = exports.findBlocksForFee = void 0;
+exports.MiscFeeLevels = void 0;
 const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
-const findBlocksForFee = (feePerUnit, blocks) => {
-    const bn = new bigNumber_1.BigNumber(feePerUnit);
-    const lower = blocks.find(b => typeof b === 'string' && bn.gte(b));
-    if (!lower)
-        return -1;
-    return blocks.indexOf(lower);
-};
-exports.findBlocksForFee = findBlocksForFee;
 class MiscFeeLevels {
     coinInfo;
     levels;
@@ -19,28 +11,21 @@ class MiscFeeLevels {
         this.coinInfo = coinInfo;
         this.levels = coinInfo.defaultFees;
     }
-    async load(blockchain) {
+    async load(blockchain, request) {
         try {
-            const [response] = await blockchain.estimateFee({ blocks: [1] });
+            const [response] = await blockchain.estimateFee(request);
+            const fee = new bigNumber_1.BigNumber(response.feePerUnit).toNumber();
+            const feePerUnit = Math.min(this.coinInfo.maxFee, Math.max(this.coinInfo.minFee, fee)).toString();
             this.levels[0] = {
                 ...this.levels[0],
                 ...response,
-                feePerUnit: Math.min(this.coinInfo.maxFee, Math.max(this.coinInfo.minFee, parseInt(response.feePerUnit ?? '0', 10))).toString(),
+                feePerUnit,
             };
         }
         catch {
         }
         return this.levels;
     }
-    updateCustomFee(feePerUnit) {
-        this.levels = this.levels.filter(l => l.label !== 'custom');
-        const blocks = (0, exports.findBlocksForFee)(feePerUnit, this.blocks);
-        this.levels.push({
-            label: 'custom',
-            feePerUnit,
-            blocks,
-        });
-    }
 }
 exports.MiscFeeLevels = MiscFeeLevels;
 //# sourceMappingURL=MiscFees.js.map

package/lib/api/composeTransaction.js

@@ -151,7 +151,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
         const discovery = this.discovery ||
             new Discovery_1.Discovery({
                 blockchain,
-                commands: this.device.getCommands(),
+                getDescriptor: path => this.device.getCommands().getAccountDescriptor(this.params.coinInfo, path),
             });
         this.discovery = discovery;
         discovery.on('progress', accounts => {
@@ -247,15 +247,16 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
         const signTxMethod = !this.device.unavailableCapabilities.replaceTransaction
             ? bitcoin_1.signTx
             : bitcoin_1.signTxLegacy;
+        const cmd = this.device.getCommands();
         const response = await signTxMethod({
-            typedCall: this.device.getCommands().typedCall.bind(this.device.getCommands()),
+            typedCall: cmd.typedCall,
             inputs,
             outputs,
             refTxs,
             options,
             coinInfo,
         });
-        await (0, bitcoin_1.verifyTx)(this.device.getCommands().getHDNode.bind(this.device.getCommands()), inputs, outputs, response.serializedTx, coinInfo);
+        await (0, bitcoin_1.verifyTx)(cmd.getHDNode, inputs, outputs, response.serializedTx, coinInfo);
         if (this.params.push) {
             const blockchain = await this.getBlockchain();
             const txid = await blockchain.pushTransaction(response.serializedTx);

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

@@ -29,7 +29,7 @@ class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
         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, this.params.chunkify);
+        const response = await helper.signTx(this.device.getCommands().typedCall, this.params.path, this.params.chain_id, this.params.header, this.params.ack, this.params.chunkify);
         return {
             signature: response.signature,
         };

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

@@ -105,15 +105,15 @@ export declare const validate: (tx: EosSDKTransaction) => {
             permission: string;
         } | undefined;
         link_auth?: {
+            code: string;
             type: string;
             account: string;
-            code: string;
             requirement: string;
         } | undefined;
         unlink_auth?: {
+            code: string;
             type: string;
             account: string;
-            code: string;
         } | undefined;
         new_account?: {
             name: string;

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

@@ -6,19 +6,16 @@ export declare class EthereumFeeLevels extends MiscFeeLevels {
     levels: FeeLevel[];
     blocks: Blocks;
     constructor(coinInfo: EthereumNetworkInfo);
-    load(blockchain: Blockchain): Promise<{
+    load(blockchain: Blockchain, request: Parameters<typeof blockchain.estimateFee>[0]): Promise<{
+        feePerTx?: string | undefined;
+        feeLimit?: string | undefined;
+        baseFeePerGas?: string | undefined;
         maxFeePerGas?: string | undefined;
         maxPriorityFeePerGas?: string | undefined;
         maxWaitTimeEstimate?: number | undefined;
-        minWaitTimeEstimate?: number | undefined;
-        feeLimit?: string | undefined;
-        feePerTx?: string | undefined;
-        baseFeePerGas?: string | undefined;
-        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
-        feePerUnit: string;
         blocks: number;
+        feePerUnit: string;
     }[]>;
-    updateEthereumCustomFee(feePerUnit: string, effectiveGasPrice?: string, maxPriorityFeePerGas?: string): void;
 }
 //# sourceMappingURL=EthereumFees.d.ts.map

package/lib/api/ethereum/EthereumFees.js

@@ -12,60 +12,46 @@ class EthereumFeeLevels extends MiscFees_1.MiscFeeLevels {
         this.coinInfo = coinInfo;
         this.levels = coinInfo.defaultFees;
     }
-    async load(blockchain) {
+    async load(blockchain, request) {
         try {
-            const [response] = await blockchain.estimateFee({ blocks: [1] });
-            if (response.eip1559) {
-                const eip1559ResponseLevelKeys = [
-                    'low',
-                    'medium',
-                    'high',
-                ];
-                const { eip1559 } = response;
-                const eip1559Levels = eip1559ResponseLevelKeys.map(levelKey => {
+            const [response] = await blockchain.estimateFee(request);
+            const { eip1559 } = response;
+            const maxFeeInWei = new bigNumber_1.BigNumber(this.coinInfo.maxFee).multipliedBy('1e+9').toNumber();
+            const minFeeInWei = new bigNumber_1.BigNumber(this.coinInfo.minFee).multipliedBy('1e+9').toNumber();
+            const feeInWei = new bigNumber_1.BigNumber(response.feePerUnit).toNumber();
+            const feePerUnit = Math.min(maxFeeInWei, Math.max(minFeeInWei, feeInWei)).toString();
+            if (eip1559?.baseFeePerGas) {
+                const levels = ['low', 'medium', 'high'].map(levelKey => {
                     const level = eip1559[levelKey];
-                    const calculatedMaxFeePerGas = bigNumber_1.BigNumber.minimum(new bigNumber_1.BigNumber(level?.maxFeePerGas || '0'), new bigNumber_1.BigNumber(eip1559.baseFeePerGas || '0').plus(level?.maxPriorityFeePerGas || '0')).toFixed();
-                    const label = levelKey === 'medium'
-                        ? 'normal'
-                        : levelKey;
+                    const label = levelKey === 'medium' ? 'normal' : levelKey;
+                    if (!level?.maxFeePerGas || !level?.maxPriorityFeePerGas) {
+                        return null;
+                    }
                     return {
                         label,
-                        maxFeePerGas: level?.maxFeePerGas || '0',
-                        effectiveGasPrice: calculatedMaxFeePerGas,
-                        maxPriorityFeePerGas: level?.maxPriorityFeePerGas || '0',
-                        baseFeePerGas: eip1559.baseFeePerGas,
-                        minWaitTimeEstimate: level?.minWaitTimeEstimate
-                            ? level.minWaitTimeEstimate / 1000
-                            : undefined,
-                        maxWaitTimeEstimate: level?.maxWaitTimeEstimate
-                            ? level.maxWaitTimeEstimate / 1000
-                            : undefined,
-                        feePerUnit: '0',
+                        feePerUnit,
                         feeLimit: response.feeLimit,
                         blocks: -1,
+                        baseFeePerGas: eip1559.baseFeePerGas,
+                        maxFeePerGas: level?.maxFeePerGas,
+                        maxPriorityFeePerGas: level?.maxPriorityFeePerGas,
+                        maxWaitTimeEstimate: level?.maxWaitTimeEstimate,
                     };
                 });
-                this.levels = [...eip1559Levels];
+                this.levels = levels.filter(level => level);
             }
             else {
-                super.load(blockchain);
+                this.levels[0] = {
+                    ...this.levels[0],
+                    ...response,
+                    feePerUnit,
+                };
             }
         }
         catch {
         }
         return this.levels;
     }
-    updateEthereumCustomFee(feePerUnit, effectiveGasPrice, maxPriorityFeePerGas) {
-        this.levels = this.levels.filter(l => l.label !== 'custom');
-        const blocks = (0, MiscFees_1.findBlocksForFee)(feePerUnit, this.blocks);
-        this.levels.push({
-            label: 'custom',
-            feePerUnit,
-            blocks,
-            maxPriorityFeePerGas,
-            effectiveGasPrice,
-        });
-    }
 }
 exports.EthereumFeeLevels = EthereumFeeLevels;
 //# sourceMappingURL=EthereumFees.js.map

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

@@ -21,11 +21,7 @@ export default class EthereumGetAddress extends AbstractMethod<'ethereumGetAddre
         view: "export-address";
         label: string;
     };
-    _call({ address_n, show_display, encoded_network, chunkify }: Params): Promise<{
-        path: number[];
-        serializedPath: string;
-        address: string;
-    }>;
+    private _call;
     run(): Promise<import("../../../types").Address | import("../../../types").Address[]>;
 }
 export {};

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

@@ -85,14 +85,13 @@ class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
             label: this.info,
         };
     }
-    _call({ address_n, show_display, encoded_network, chunkify }) {
-        const cmd = this.device.getCommands();
-        return cmd.ethereumGetAddress({
-            address_n,
-            show_display,
-            encoded_network,
-            chunkify,
-        });
+    async _call(params) {
+        const response = await this.device.getCommands().ethereumGetAddress(params);
+        return {
+            path: params.address_n,
+            serializedPath: (0, pathUtils_1.getSerializedPath)(params.address_n),
+            address: response.address,
+        };
     }
     async run() {
         const responses = [];

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

@@ -12,29 +12,33 @@ export default class EthereumGetPublicKey extends AbstractMethod<'ethereumGetPub
         view: "export-xpub";
         label: string;
     };
-    run(): Promise<{
-        xpubSegwit?: string | undefined;
-        descriptorChecksum?: string | undefined;
+    run(): Promise<({
         path: number[];
         publicKey: string;
         serializedPath: string;
+    } & {
+        descriptor?: string | undefined;
+        xpubSegwit?: string | undefined;
+        descriptorChecksum?: string | undefined;
         depth: number;
         fingerprint: number;
         chainCode: string;
         childNum: number;
         xpub: string;
-    } | {
-        xpubSegwit?: string | undefined;
-        descriptorChecksum?: string | undefined;
+    }) | ({
         path: number[];
         publicKey: string;
         serializedPath: string;
+    } & {
+        descriptor?: string | undefined;
+        xpubSegwit?: string | undefined;
+        descriptorChecksum?: string | undefined;
         depth: number;
         fingerprint: number;
         chainCode: string;
         childNum: number;
         xpub: string;
-    }[]>;
+    })[]>;
 }
 export {};
 //# sourceMappingURL=ethereumGetPublicKey.d.ts.map

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

@@ -50,11 +50,18 @@ class EthereumGetPublicKey extends AbstractMethod_1.AbstractMethod {
         const responses = [];
         const cmd = this.device.getCommands();
         for (let i = 0; i < this.params.length; i++) {
-            const batch = this.params[i];
-            const response = await cmd.ethereumGetPublicKey({
-                address_n: batch.address_n,
-                show_display: batch.show_display,
-            });
+            const { address_n, show_display } = this.params[i];
+            const publicKey = await cmd.ethereumGetPublicKey({ address_n, show_display });
+            const response = {
+                path: address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
+                childNum: publicKey.node.child_num,
+                xpub: publicKey.xpub,
+                chainCode: publicKey.node.chain_code,
+                publicKey: publicKey.node.public_key,
+                fingerprint: publicKey.node.fingerprint,
+                depth: publicKey.node.depth,
+            };
             responses.push(response);
             if (this.hasBundle) {
                 this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {

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

@@ -63,8 +63,8 @@ class EthereumSignTransaction extends AbstractMethod_1.AbstractMethod {
         const { type, tx, definitions, chunkify } = this.params;
         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);
+            ? await helper.ethereumSignTx(this.device.getCommands().typedCall, 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, this.params.path, tx.to, tx.value, tx.gasLimit, tx.maxFeePerGas, tx.maxPriorityFeePerGas, tx.nonce, tx.chainId, chunkify, tx.data, tx.accessList, definitions);
         const serializedTx = helper.serializeEthereumTx(tx, signature, isLegacy);
         return { ...signature, serializedTx };
     }