feat(suite): build priority fees levels

trezor · Jan 17, 2025 · 5bfb927 · 5bfb927
1 parent f54f628
commit 5bfb927
Show file tree

Hide file tree

Showing 9 changed files with 90 additions and 20 deletions.
diff --git a/packages/blockchain-link-types/src/responses.ts b/packages/blockchain-link-types/src/responses.ts
@@ -92,12 +92,33 @@ export interface GetFiatRatesTickersList {
     };
 }
 
+export interface PriorityFeeEstimationDetails {
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    minWaitTimeEstimate: number;
+    maxWaitTimeEstimate: number;
+}
+
+export type FeeTrend = 'up' | 'down';
+
 export interface EstimateFee {
     type: typeof RESPONSES.ESTIMATE_FEE;
     payload: {
         feePerUnit: string;
         feePerTx?: string;
         feeLimit?: string;
+        eip1559?: {
+            baseFeePerGas: string;
+            low: PriorityFeeEstimationDetails;
+            medium: PriorityFeeEstimationDetails;
+            high: PriorityFeeEstimationDetails;
+            networkCongestion: number;
+            latestPriorityFeeRange: string[];
+            historicalPriorityFeeRange: string[];
+            historicalBaseFeeRange: string[];
+            priorityFeeTrend: FeeTrend;
+            baseFeeTrend: FeeTrend;
+        };
     }[];
 }
 

diff --git a/packages/connect/src/api/bitcoin/Fees.ts b/packages/connect/src/api/bitcoin/Fees.ts
@@ -82,19 +82,48 @@ export class FeeLevels {
     async loadMisc(blockchain: Blockchain) {
         try {
             const [response] = await blockchain.estimateFee({ blocks: [1] });
+
+            if (response.eip1559) {
+                const eip1559LevelKeys = ['low', 'medium', 'high'] as const;
+
+                const { eip1559, ...baseLevel } = response;
+                const eip1559Levels = eip1559LevelKeys.map(levelKey => {
+                    const level = eip1559[levelKey];
+
+                    return {
+                        label: levelKey,
+                        baseFeePerGas: eip1559.baseFeePerGas,
+                        maxFeePerGas: level.maxFeePerGas,
+                        maxPriorityFeePerGas: level.maxPriorityFeePerGas,
+                        minWaitTimeEstimate: level.minWaitTimeEstimate,
+                        maxWaitTimeEstimate: level.maxWaitTimeEstimate,
+                        feePerUnit: '0',
+                        feeLimit: undefined,
+                        ethFeeType: 'eip1559' as const,
+                        blocks: -1,
+                    };
+                });
+
+                this.levels = [
+                    { ...baseLevel, label: 'normal' as const, blocks: -1, ethFeeType: 'legacy' },
+                    ...eip1559Levels,
+                ];
+            } else {
+                this.levels[0] = {
+                    ...this.levels[0],
+                    ...response,
+                    // validate `feePerUnit` from the backend
+                    // should be lower than `coinInfo.maxFee` and higher than `coinInfo.minFee`
+                    // xrp sends values from 1 to very high number occasionally
+                    // see: https://github.com/trezor/trezor-suite/blob/develop/packages/blockchain-link/src/workers/ripple/index.ts#L316
+                    feePerUnit: Math.min(
+                        this.coinInfo.maxFee,
+                        Math.max(this.coinInfo.minFee, parseInt(response.feePerUnit, 10)),
+                    ).toString(),
+                };
+            }
+
             // misc coins should have only one FeeLevel (normal)
-            this.levels[0] = {
-                ...this.levels[0],
-                ...response,
-                // validate `feePerUnit` from the backend
-                // should be lower than `coinInfo.maxFee` and higher than `coinInfo.minFee`
-                // xrp sends values from 1 to very high number occasionally
-                // see: https://github.com/trezor/trezor-suite/blob/develop/packages/blockchain-link/src/workers/ripple/index.ts#L316
-                feePerUnit: Math.min(
-                    this.coinInfo.maxFee,
-                    Math.max(this.coinInfo.minFee, parseInt(response.feePerUnit, 10)),
-                ).toString(),
-            };
         } catch {
             // silent
         }

diff --git a/packages/connect/src/types/fees.ts b/packages/connect/src/types/fees.ts
@@ -8,6 +8,14 @@ export const FeeInfo = Type.Object({
     dustLimit: Type.Number(),
 });
 
+export type PriorityFeeEstimationDetails = Static<typeof PriorityFeeEstimationDetails>;
+export const PriorityFeeEstimationDetails = Type.Object({
+    maxFeePerGas: Type.String(),
+    maxPriorityFeePerGas: Type.String(),
+    maxWaitTimeEstimate: Type.Number(),
+    minWaitTimeEstimate: Type.Number(),
+});
+
 export type FeeLevel = Static<typeof FeeLevel>;
 export const FeeLevel = Type.Object({
     label: Type.Union([
@@ -16,11 +24,18 @@ export const FeeLevel = Type.Object({
         Type.Literal('economy'),
         Type.Literal('low'),
         Type.Literal('custom'),
+        Type.Literal('medium'),
     ]),
+    ethFeeType: Type.Optional(Type.Union([Type.Literal('legacy'), Type.Literal('eip1559')])),
     feePerUnit: Type.String(),
     blocks: Type.Number(),
     feeLimit: Type.Optional(Type.String()), // eth gas limit
     feePerTx: Type.Optional(Type.String()), // fee for BlockchainEstimateFeeParams.request.specific
+    baseFeePerGas: Type.Optional(Type.String()),
+    maxFeePerGas: Type.Optional(Type.String()),
+    maxPriorityFeePerGas: Type.Optional(Type.String()),
+    maxWaitTimeEstimate: Type.Optional(Type.Number()),
+    minWaitTimeEstimate: Type.Optional(Type.Number()),
 });
 
 export type SelectFeeLevel = Static<typeof SelectFeeLevel>;

diff --git a/packages/suite/src/components/wallet/Fees/Fees.tsx b/packages/suite/src/components/wallet/Fees/Fees.tsx
@@ -44,6 +44,7 @@ const FEE_LEVELS_TRANSLATIONS: Record<FeeLevel['label'], TranslationKey> = {
     normal: 'FEE_LEVEL_NORMAL',
     economy: 'FEE_LEVEL_LOW',
     low: 'FEE_LEVEL_LOW',
+    medium: 'FEE_LEVEL_MEDIUM',
 } as const;
 
 const buildFeeOptions = (levels: FeeLevel[]) =>

diff --git a/packages/suite/src/support/messages.ts b/packages/suite/src/support/messages.ts
@@ -5592,6 +5592,10 @@ export default defineMessages({
         defaultMessage: 'Low',
         id: 'FEE_LEVEL_LOW',
     },
+    FEE_LEVEL_MEDIUM: {
+        defaultMessage: 'Medium',
+        id: 'FEE_LEVEL_MEDIUM',
+    },
     CUSTOM_FEE_IS_NOT_SET: {
         defaultMessage:
             'Enter the fee rate you want to spend in order to complete this transaction.',

diff --git a/suite-common/wallet-core/src/blockchain/blockchainThunks.ts b/suite-common/wallet-core/src/blockchain/blockchainThunks.ts
@@ -58,7 +58,7 @@ const getAccountSyncInterval = (symbol: NetworkSymbol) =>
 
 // sort FeeLevels in reversed order (Low > High)
 // TODO: consider to use same order in @trezor/connect to avoid double sorting
-const order: FeeLevel['label'][] = ['low', 'economy', 'normal', 'high'];
+const order: FeeLevel['label'][] = ['low', 'economy', 'medium', 'normal', 'high'];
 const sortLevels = (levels: FeeLevel[]) =>
     levels.sort((levelA, levelB) => order.indexOf(levelA.label) - order.indexOf(levelB.label));
 
@@ -124,13 +124,11 @@ export const updateFeeInfoThunk = createThunk(
         let newFeeInfo;
 
         if (network.networkType === 'ethereum') {
-            // NOTE: ethereum smart fees are not implemented properly in @trezor/connect Issue: https://github.com/trezor/trezor-suite/issues/5340
-            // create raw call to @trezor/blockchain-link, receive data and create FeeLevel.normal from it
-
             const result = await TrezorConnect.blockchainEstimateFee({
                 coin: network.symbol,
                 request: {
                     blocks: [2],
+                    feeLevels: 'smart',
                     specific: {
                         from: '0x0000000000000000000000000000000000000000',
                         to: '0x0000000000000000000000000000000000000000',
@@ -143,7 +141,7 @@ export const updateFeeInfoThunk = createThunk(
                     levels: result.payload.levels.map(l => ({
                         ...l,
                         blocks: -1, // NOTE: @trezor/connect returns -1 for ethereum default
-                        label: 'normal' as const,
+                        label: l.label || ('normal' as const),
                     })),
                 };
             }

diff --git a/suite-common/wallet-types/src/transaction.ts b/suite-common/wallet-types/src/transaction.ts
@@ -77,8 +77,10 @@ export type EthTransactionData = {
     amount: string;
     data?: string;
     gasLimit: string;
-    gasPrice: string;
     nonce: string;
+    gasPrice?: string; // this field is not used for EIP1559 transactions (See EthereumTransaction and EthereumTransactionEIP1559 types in connect)
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
 };
 
 export type ExternalOutput = Exclude<ComposeOutput, { type: 'opreturn' } | { address_n: number[] }>;

diff --git a/suite-common/wallet-utils/src/sendFormUtils.ts b/suite-common/wallet-utils/src/sendFormUtils.ts
@@ -146,7 +146,7 @@ export const prepareEthereumTransaction = (txInfo: EthTransactionData) => {
         chainId: txInfo.chainId,
         nonce: numberToHex(txInfo.nonce),
         gasLimit: numberToHex(txInfo.gasLimit),
-        gasPrice: numberToHex(toWei(txInfo.gasPrice, 'gwei')),
+        gasPrice: numberToHex(toWei(txInfo.gasPrice || '0', 'gwei')),
     };
 
     if (!txInfo.token && txInfo.data) {

diff --git a/suite-native/module-send/src/types.ts b/suite-native/module-send/src/types.ts
@@ -13,7 +13,7 @@ import type { NetworkSymbol } from '@suite-common/wallet-config';
 
 export type StatefulReviewOutput = ReviewOutput & { state: ReviewOutputState };
 
-export type NativeSupportedFeeLevel = Exclude<FeeLevelLabel, 'low'>;
+export type NativeSupportedFeeLevel = Exclude<FeeLevelLabel, 'low' | 'medium'>;
 
 export type SendAmountInputProps = {
     recipientIndex: number;