@trezor/connect 9.5.4 → 9.5.5-beta.2

package/lib/api/signTransaction.d.ts

@@ -18,6 +18,211 @@ type Params = {
 export default class SignTransaction extends AbstractMethod<'signTransaction', Params> {
     init(): void;
     get info(): string;
+    payloadToPrecomposed(): Promise<{
+        type: "final";
+        inputs: (({
+            sequence?: number | undefined;
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    public_key: string;
+                    depth: number;
+                    fingerprint: number;
+                    child_num: number;
+                    chain_code: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        public_key: string;
+                        depth: number;
+                        fingerprint: number;
+                        child_num: number;
+                        chain_code: string;
+                    };
+                }[];
+                signatures: string[];
+                m: number;
+            } | undefined;
+            decred_tree?: number | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            decred_staking_spend?: PROTO.DecredStakingSpendType | undefined;
+            script_pubkey?: string | undefined;
+            coinjoin_flags?: number | undefined;
+            script_sig?: string | undefined;
+            witness?: string | undefined;
+            ownership_proof?: string | undefined;
+            commitment_data?: string | undefined;
+            amount: string | number;
+            prev_hash: string;
+            prev_index: number;
+        } & {
+            script_type?: "SPENDADDRESS" | "SPENDMULTISIG" | "SPENDWITNESS" | "SPENDP2SHWITNESS" | "SPENDTAPROOT" | undefined;
+            address_n: number[];
+        }) | ({
+            sequence?: number | undefined;
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    public_key: string;
+                    depth: number;
+                    fingerprint: number;
+                    child_num: number;
+                    chain_code: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        public_key: string;
+                        depth: number;
+                        fingerprint: number;
+                        child_num: number;
+                        chain_code: string;
+                    };
+                }[];
+                signatures: string[];
+                m: number;
+            } | undefined;
+            decred_tree?: number | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            decred_staking_spend?: PROTO.DecredStakingSpendType | undefined;
+            script_pubkey?: string | undefined;
+            coinjoin_flags?: number | undefined;
+            script_sig?: string | undefined;
+            witness?: string | undefined;
+            ownership_proof?: string | undefined;
+            commitment_data?: string | undefined;
+            amount: string | number;
+            prev_hash: string;
+            prev_index: number;
+        } & {
+            address_n?: undefined;
+            script_pubkey: string;
+            script_type: "EXTERNAL";
+        }))[];
+        outputs: ({
+            address_n?: undefined;
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    public_key: string;
+                    depth: number;
+                    fingerprint: number;
+                    child_num: number;
+                    chain_code: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        public_key: string;
+                        depth: number;
+                        fingerprint: number;
+                        child_num: number;
+                        chain_code: string;
+                    };
+                }[];
+                signatures: string[];
+                m: number;
+            } | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            payment_req_index?: number | undefined;
+            address: string;
+            amount: string | number;
+            script_type: "PAYTOADDRESS";
+        } | {
+            address?: undefined;
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    public_key: string;
+                    depth: number;
+                    fingerprint: number;
+                    child_num: number;
+                    chain_code: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        public_key: string;
+                        depth: number;
+                        fingerprint: number;
+                        child_num: number;
+                        chain_code: string;
+                    };
+                }[];
+                signatures: string[];
+                m: number;
+            } | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            script_type?: "PAYTOADDRESS" | "PAYTOSCRIPTHASH" | "PAYTOMULTISIG" | "PAYTOWITNESS" | "PAYTOP2SHWITNESS" | "PAYTOTAPROOT" | undefined;
+            payment_req_index?: number | undefined;
+            address_n: number[];
+            amount: string | number;
+        } | {
+            address_n?: undefined;
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    public_key: string;
+                    depth: number;
+                    fingerprint: number;
+                    child_num: number;
+                    chain_code: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        public_key: string;
+                        depth: number;
+                        fingerprint: number;
+                        child_num: number;
+                        chain_code: string;
+                    };
+                }[];
+                signatures: string[];
+                m: number;
+            } | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            script_type?: "PAYTOADDRESS" | "PAYTOSCRIPTHASH" | "PAYTOMULTISIG" | "PAYTOWITNESS" | "PAYTOP2SHWITNESS" | "PAYTOTAPROOT" | undefined;
+            payment_req_index?: number | undefined;
+            address: string;
+            amount: string | number;
+        } | {
+            address_n?: undefined;
+            address?: undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            payment_req_index?: number | undefined;
+            amount: 0 | "0";
+            script_type: "PAYTOOPRETURN";
+            op_return_data: string;
+        })[];
+        outputsPermutation: number[];
+        totalSpent: string;
+        fee: string;
+        feePerByte: string;
+        bytes: number;
+    } | undefined>;
     private fetchAddresses;
     private fetchRefTxs;
     run(): Promise<import("../types").SignedTransaction>;

package/lib/api/signTransaction.js

@@ -8,6 +8,7 @@ const AbstractMethod_1 = require("../core/AbstractMethod");
 const paramsValidator_1 = require("./common/paramsValidator");
 const coinInfo_1 = require("../data/coinInfo");
 const pathUtils_1 = require("../utils/pathUtils");
+const transactionBytes_1 = require("./bitcoin/transactionBytes");
 class SignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
@@ -102,6 +103,48 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(this.payload.coin);
         return (0, pathUtils_1.getLabel)('Sign #NETWORK transaction', coinInfo);
     }
+    async payloadToPrecomposed() {
+        try {
+            const { inputs, outputs, coinInfo } = this.params;
+            const refTxs = this.params.refTxs ?? (await this.fetchRefTxs(false));
+            const inputsTotal = inputs.reduce((bn, input) => {
+                if (typeof input.amount === 'string') {
+                    return bn.plus(input.amount);
+                }
+                else {
+                    const refTx = refTxs.find(tx => tx.hash === input.prev_hash);
+                    const refOutput = refTx?.outputs?.[input.prev_index] ??
+                        refTx?.bin_outputs?.[input.prev_index];
+                    if (refOutput)
+                        return bn.plus(refOutput.amount);
+                }
+                return bn;
+            }, new bigNumber_1.BigNumber(0));
+            const outputsTotal = outputs.reduce((bn, output) => bn.plus(typeof output.amount === 'string' ? output.amount : '0'), new bigNumber_1.BigNumber(0));
+            const bytes = (0, transactionBytes_1.getTransactionVbytes)(inputs, outputs, coinInfo);
+            if (!bytes)
+                throw constants_1.ERRORS.TypedError('Runtime', 'Transaction bytes not calculated');
+            const fee = inputsTotal.minus(outputsTotal);
+            if (fee.lte(0)) {
+                throw constants_1.ERRORS.TypedError('Runtime', 'Computed fee is non-positive');
+            }
+            const feePerByte = fee.dividedBy(bytes);
+            return {
+                type: 'final',
+                inputs,
+                outputs,
+                outputsPermutation: Array.from({ length: outputs.length }, (_, i) => i),
+                totalSpent: inputsTotal.toString(),
+                fee: fee.toString(),
+                feePerByte: feePerByte.toString(),
+                bytes,
+            };
+        }
+        catch (e) {
+            console.error('Error in payloadToPrecomposed', e);
+            return undefined;
+        }
+    }
     async fetchAddresses(blockchain) {
         const { device, params: { inputs, coinInfo }, } = this;
         const accountPath = inputs.find(i => i.address_n);

package/lib/api/solana/api/solanaSignTransaction.d.ts

@@ -1,3 +1,4 @@
+import { TokenInfo } from '@trezor/blockchain-link-types';
 import { PROTO } from '../../../constants';
 import { AbstractMethod } from '../../../core/AbstractMethod';
 type Params = PROTO.SolanaSignTx & {
@@ -6,6 +7,25 @@ type Params = PROTO.SolanaSignTx & {
 export default class SolanaSignTransaction extends AbstractMethod<'solanaSignTransaction', Params> {
     init(): void;
     get info(): string;
+    payloadToPrecomposed(): Promise<undefined> | Promise<{
+        type: "final";
+        inputs: never[];
+        outputsPermutation: number[];
+        outputs: {
+            address: string;
+            amount: string;
+            script_type: "PAYTOADDRESS";
+        }[];
+        totalSpent: string;
+        fee: string;
+        feePerByte: string;
+        feeLimit: string;
+        bytes: number;
+        max: undefined;
+        isTokenKnown: boolean;
+        token: TokenInfo | undefined;
+        createdTimestamp: number | undefined;
+    }>;
     run(): Promise<{
         signature: string;
         serializedTx: string;

package/lib/api/solana/api/solanaSignTransaction.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const kit_1 = require("@solana/kit");
+const compute_budget_1 = require("@solana-program/compute-budget");
+const system_1 = require("@solana-program/system");
+const token_1 = require("@solana-program/token");
 const schema_utils_1 = require("@trezor/schema-utils");
+const utils_1 = require("@trezor/utils");
+const constants_1 = require("../../../constants");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const coinInfo_1 = require("../../../data/coinInfo");
 const solana_1 = require("../../../types/api/solana");
@@ -26,6 +32,132 @@ class SolanaSignTransaction extends AbstractMethod_1.AbstractMethod {
     get info() {
         return 'Sign Solana transaction';
     }
+    payloadToPrecomposed() {
+        try {
+            let messageBytes;
+            if (this.payload.serialize) {
+                const transaction = (0, kit_1.pipe)(this.payload.serializedTx, (0, kit_1.getBase16Encoder)().encode, (0, kit_1.getTransactionDecoder)().decode);
+                messageBytes = transaction.messageBytes;
+            }
+            else {
+                messageBytes = (0, kit_1.getBase16Encoder)().encode(this.payload.serializedTx);
+            }
+            const compiledMessage = (0, kit_1.pipe)(messageBytes, (0, kit_1.getCompiledTransactionMessageDecoder)().decode);
+            const message = (0, kit_1.decompileTransactionMessage)(compiledMessage);
+            const baseFee = new utils_1.BigNumber(solanaUtils_1.SOLANA_BASE_FEE).multipliedBy(compiledMessage.header.numSignerAccounts);
+            const outputs = [];
+            let feePerUnit = new utils_1.BigNumber(0);
+            let feeLimit = new utils_1.BigNumber(0);
+            let rent = new utils_1.BigNumber(0);
+            let sendAmount = new utils_1.BigNumber(0);
+            let token;
+            for (const instruction of message.instructions) {
+                if (instruction.programAddress === compute_budget_1.COMPUTE_BUDGET_PROGRAM_ADDRESS &&
+                    instruction.data) {
+                    const data = instruction.data;
+                    const type = (0, compute_budget_1.identifyComputeBudgetInstruction)({ data });
+                    if (type === compute_budget_1.ComputeBudgetInstruction.SetComputeUnitPrice) {
+                        const parsed = (0, compute_budget_1.parseSetComputeUnitPriceInstruction)({
+                            data,
+                            programAddress: compute_budget_1.COMPUTE_BUDGET_PROGRAM_ADDRESS,
+                        });
+                        feePerUnit = new utils_1.BigNumber(parsed.data.microLamports.toString());
+                    }
+                    if (type === compute_budget_1.ComputeBudgetInstruction.SetComputeUnitLimit) {
+                        const parsed = (0, compute_budget_1.parseSetComputeUnitLimitInstruction)({
+                            data,
+                            programAddress: compute_budget_1.COMPUTE_BUDGET_PROGRAM_ADDRESS,
+                        });
+                        feeLimit = new utils_1.BigNumber(parsed.data.units.toString());
+                    }
+                }
+                if (instruction.programAddress === system_1.SYSTEM_PROGRAM_ADDRESS &&
+                    instruction.data &&
+                    instruction.accounts) {
+                    const instructionSafe = {
+                        ...instruction,
+                        data: instruction.data,
+                        accounts: instruction.accounts,
+                    };
+                    const type = (0, system_1.identifySystemInstruction)(instructionSafe);
+                    if (type === system_1.SystemInstruction.TransferSol) {
+                        const parsed = (0, system_1.parseTransferSolInstruction)(instructionSafe);
+                        outputs.push({
+                            address: parsed.accounts.destination.address,
+                            amount: parsed.data.amount.toString(),
+                            script_type: 'PAYTOADDRESS',
+                        });
+                        sendAmount = sendAmount.plus(parsed.data.amount.toString());
+                    }
+                    else if (type === system_1.SystemInstruction.CreateAccount) {
+                        const parsed = (0, system_1.parseCreateAccountInstruction)(instructionSafe);
+                        outputs.push({
+                            address: parsed.accounts.newAccount.address,
+                            amount: parsed.data.lamports.toString(),
+                            script_type: 'PAYTOADDRESS',
+                        });
+                        rent = rent.plus(parsed.data.lamports.toString());
+                    }
+                }
+                if (instruction.programAddress === token_1.TOKEN_PROGRAM_ADDRESS &&
+                    instruction.data &&
+                    instruction.accounts) {
+                    const instructionSafe = {
+                        ...instruction,
+                        data: instruction.data,
+                        accounts: instruction.accounts,
+                    };
+                    const type = (0, token_1.identifyTokenInstruction)(instructionSafe);
+                    if (type === token_1.TokenInstruction.TransferChecked) {
+                        const parsed = (0, token_1.parseTransferCheckedInstruction)(instructionSafe);
+                        const destinationATA = parsed.accounts.destination.address;
+                        const tokenInfo = this.payload.additionalInfo?.tokenAccountsInfos?.find(t => t.tokenAccount === destinationATA &&
+                            t.tokenMint === parsed.accounts.mint.address);
+                        if (!sendAmount.isZero()) {
+                            throw constants_1.ERRORS.TypedError('Runtime', 'Multiple token transfers in a single transaction are not supported');
+                        }
+                        outputs.push({
+                            address: tokenInfo?.baseAddress || destinationATA,
+                            amount: parsed.data.amount.toString(),
+                            script_type: 'PAYTOADDRESS',
+                        });
+                        sendAmount = new utils_1.BigNumber(parsed.data.amount.toString());
+                        token = {
+                            type: 'SPL',
+                            standard: 'SPL',
+                            contract: parsed.accounts.mint.address,
+                            decimals: parsed.data.decimals,
+                            symbol: tokenInfo?.symbol,
+                        };
+                    }
+                }
+            }
+            if (outputs.length === 0) {
+                throw constants_1.ERRORS.TypedError('Runtime', 'No outputs decoded');
+            }
+            const fee = baseFee.plus(feePerUnit.multipliedBy(feeLimit).dividedBy(1e6));
+            const totalSpent = sendAmount.plus(rent).plus(fee);
+            return Promise.resolve({
+                type: 'final',
+                inputs: [],
+                outputsPermutation: [0],
+                outputs,
+                totalSpent: token ? sendAmount.toString() : totalSpent.toString(),
+                fee: fee.toString(),
+                feePerByte: feePerUnit.toString(),
+                feeLimit: feeLimit.toString(),
+                bytes: 0,
+                max: undefined,
+                isTokenKnown: false,
+                token,
+                createdTimestamp: 'blockhash' in message.lifetimeConstraint ? new Date().getTime() : undefined,
+            });
+        }
+        catch (e) {
+            console.error('Error in payloadToPrecomposed', e);
+            return Promise.resolve(undefined);
+        }
+    }
     async run() {
         const cmd = this.device.getCommands();
         if (this.params.serialize) {

package/lib/api/solana/solanaUtils.d.ts

@@ -3,6 +3,7 @@ import type { TokenAccount } from '@trezor/blockchain-link-types';
 import type { TokenProgramName } from '@trezor/blockchain-link-utils/lib/solana';
 import { BigNumber } from '@trezor/utils/lib/bigNumber';
 import { Blockchain } from '../../backend/Blockchain';
+export declare const SOLANA_BASE_FEE = 5000;
 export declare const getLamportsFromSol: (amountInSol: string) => bigint;
 type PriorityFees = {
     computeUnitPrice: string;

package/lib/api/solana/solanaUtils.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchAccountOwnerAndTokenInfoForAddress = exports.buildTokenTransferTransaction = exports.getMinimumRequiredTokenAccountsForTransfer = exports.buildCreateAssociatedTokenAccountInstruction = exports.getAssociatedTokenAccountAddress = exports.buildTokenTransferInstruction = exports.buildTransferTransaction = exports.dummyPriorityFeesForFeeEstimation = exports.getLamportsFromSol = void 0;
+exports.fetchAccountOwnerAndTokenInfoForAddress = exports.buildTokenTransferTransaction = exports.getMinimumRequiredTokenAccountsForTransfer = exports.buildCreateAssociatedTokenAccountInstruction = exports.getAssociatedTokenAccountAddress = exports.buildTokenTransferInstruction = exports.buildTransferTransaction = exports.dummyPriorityFeesForFeeEstimation = exports.getLamportsFromSol = exports.SOLANA_BASE_FEE = void 0;
 exports.createTransactionShim = createTransactionShim;
 exports.createTransactionShimFromHex = createTransactionShimFromHex;
 const ts_belt_1 = require("@mobily/ts-belt");
@@ -53,6 +53,7 @@ const loadSolanaTokenProgramLib = async (tokenProgramName) => {
             throw new Error(`Unsupported token program: ${tokenProgramName}`);
     }
 };
+exports.SOLANA_BASE_FEE = 5000;
 const getLamportsFromSol = (amountInSol) => BigInt(new bigNumber_1.BigNumber(amountInSol).times(10 ** 9).toString());
 exports.getLamportsFromSol = getLamportsFromSol;
 exports.dummyPriorityFeesForFeeEstimation = {

package/lib/backend/BackendManager.js

@@ -107,7 +107,7 @@ class BackendManager {
     patchCoinInfo(coinInfo) {
         const custom = this.custom[coinInfo.shortcut];
         const preferred = this.preferred[coinInfo.shortcut];
-        const url = preferred ? [preferred] : custom?.url ?? coinInfo.blockchainLink?.url;
+        const url = preferred ? [preferred] : (custom?.url ?? coinInfo.blockchainLink?.url);
         return {
             ...coinInfo,
             blockchainLink: {

package/lib/backend/Blockchain.d.ts

@@ -1,4 +1,4 @@
-import BlockchainLink, { BlockchainLinkParams, BlockchainLinkResponse, ServerInfo, SubscriptionAccountInfo } from '@trezor/blockchain-link';
+import BlockchainLink, { BlockchainLinkParams, ServerInfo, SubscriptionAccountInfo } from '@trezor/blockchain-link';
 import { ERRORS } from '../constants';
 import { CoreEventMessage } from '../events';
 import type { CoinInfo, Proxy } from '../types';
@@ -16,8 +16,6 @@ export declare class Blockchain {
     readonly identity?: string;
     readonly coinInfo: BlockchainOptions['coinInfo'];
     readonly postMessage: BlockchainOptions['postMessage'];
-    feeForBlock: BlockchainLinkResponse<'estimateFee'>;
-    feeTimestamp: number;
     private onDisconnected;
     private initPromise?;
     constructor(options: BlockchainOptions);

package/lib/backend/Blockchain.js

@@ -34,8 +34,6 @@ class Blockchain {
     identity;
     coinInfo;
     postMessage;
-    feeForBlock = [];
-    feeTimestamp = 0;
     onDisconnected;
     initPromise;
     constructor(options) {
@@ -147,25 +145,7 @@ class Blockchain {
     rpcCall(params) {
         return this.link.rpcCall(params);
     }
-    async estimateFee(request) {
-        const { blocks } = request;
-        const useCache = !request.specific && Array.isArray(blocks) && blocks.length > 0;
-        if (useCache) {
-            const outdated = Date.now() - this.feeTimestamp > 20 * 60 * 1000;
-            const unknownBlocks = outdated
-                ? blocks
-                : blocks.filter(block => !this.feeForBlock[block]);
-            if (unknownBlocks.length < 1) {
-                return blocks.map(block => this.feeForBlock[block]);
-            }
-            this.feeForBlock = [];
-            const fees = await this.link.estimateFee(request);
-            blocks.forEach((block, index) => {
-                this.feeForBlock[block] = fees[index];
-            });
-            this.feeTimestamp = Date.now();
-            return fees;
-        }
+    estimateFee(request) {
         return this.link.estimateFee(request);
     }
     subscribeBlocks() {

package/lib/{api/bitcoin/BitcoinFees.d.ts → backend/fees/BitcoinFeeLevels.d.ts}

@@ -1,9 +1,8 @@
-import { Blockchain } from '../../backend/BlockchainLink';
-import type { BitcoinNetworkInfo, FeeLevel } from '../../types';
-import { Blocks } from '../common/MiscFees';
-export declare class BitcoinFeeLevels {
+import type { BitcoinNetworkInfo } from '../../types';
+import { Blockchain } from '../Blockchain';
+import { Blocks, MiscFeeLevels } from './MiscFeeLevels';
+export declare class BitcoinFeeLevels extends MiscFeeLevels {
     coinInfo: BitcoinNetworkInfo;
-    levels: FeeLevel[];
     longTermFeeRate?: string;
     blocks: Blocks;
     constructor(coinInfo: BitcoinNetworkInfo);
@@ -20,4 +19,4 @@ export declare class BitcoinFeeLevels {
     }[]>;
     updateBitcoinCustomFee(feePerUnit: string): void;
 }
-//# sourceMappingURL=BitcoinFees.d.ts.map
+//# sourceMappingURL=BitcoinFeeLevels.d.ts.map

package/lib/{api/bitcoin/BitcoinFees.js → backend/fees/BitcoinFeeLevels.js}

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitcoinFeeLevels = void 0;
 const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
+const MiscFeeLevels_1 = require("./MiscFeeLevels");
 const findBlocksForFee = (feePerUnit, blocks) => {
     const fee = new bigNumber_1.BigNumber(feePerUnit);
     const lower = blocks.find(block => typeof block === 'string' && fee.gte(block));
@@ -46,14 +47,13 @@ const findLowest = (blocks) => blocks
     .slice(0)
     .reverse()
     .find(item => typeof item === 'string');
-class BitcoinFeeLevels {
+class BitcoinFeeLevels extends MiscFeeLevels_1.MiscFeeLevels {
     coinInfo;
-    levels;
     longTermFeeRate;
     blocks = [];
     constructor(coinInfo) {
+        super(coinInfo);
         this.coinInfo = coinInfo;
-        this.levels = coinInfo.defaultFees;
     }
     async load(blockchain) {
         let blocks = fillGap(0, 1, 10);
@@ -85,6 +85,7 @@ class BitcoinFeeLevels {
                 }
             });
             this.longTermFeeRate = findLowest(this.blocks);
+            this.wasFetchedSuccessfully = true;
         }
         catch {
         }
@@ -101,4 +102,4 @@ class BitcoinFeeLevels {
     }
 }
 exports.BitcoinFeeLevels = BitcoinFeeLevels;
-//# sourceMappingURL=BitcoinFees.js.map
+//# sourceMappingURL=BitcoinFeeLevels.js.map

package/lib/{api/ethereum/EthereumFees.d.ts → backend/fees/EthereumFeeLevels.d.ts}

@@ -1,9 +1,8 @@
-import { Blockchain } from '../../backend/BlockchainLink';
-import type { EthereumNetworkInfo, FeeLevel } from '../../types';
-import { Blocks, MiscFeeLevels } from '../common/MiscFees';
+import type { EthereumNetworkInfo } from '../../types';
+import { Blockchain } from '../Blockchain';
+import { Blocks, MiscFeeLevels } from './MiscFeeLevels';
 export declare class EthereumFeeLevels extends MiscFeeLevels {
     coinInfo: EthereumNetworkInfo;
-    levels: FeeLevel[];
     blocks: Blocks;
     constructor(coinInfo: EthereumNetworkInfo);
     load(blockchain: Blockchain, request: Parameters<typeof blockchain.estimateFee>[0]): Promise<{
@@ -18,4 +17,4 @@ export declare class EthereumFeeLevels extends MiscFeeLevels {
         feePerUnit: string;
     }[]>;
 }
-//# sourceMappingURL=EthereumFees.d.ts.map
+//# sourceMappingURL=EthereumFeeLevels.d.ts.map

package/lib/{api/ethereum/EthereumFees.js → backend/fees/EthereumFeeLevels.js}

@@ -2,15 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EthereumFeeLevels = void 0;
 const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
-const MiscFees_1 = require("../common/MiscFees");
-class EthereumFeeLevels extends MiscFees_1.MiscFeeLevels {
+const MiscFeeLevels_1 = require("./MiscFeeLevels");
+class EthereumFeeLevels extends MiscFeeLevels_1.MiscFeeLevels {
     coinInfo;
-    levels;
     blocks = [];
     constructor(coinInfo) {
         super(coinInfo);
         this.coinInfo = coinInfo;
-        this.levels = coinInfo.defaultFees;
     }
     async load(blockchain, request) {
         try {
@@ -47,6 +45,7 @@ class EthereumFeeLevels extends MiscFees_1.MiscFeeLevels {
                     feePerUnit,
                 };
             }
+            this.wasFetchedSuccessfully = true;
         }
         catch {
         }
@@ -54,4 +53,4 @@ class EthereumFeeLevels extends MiscFees_1.MiscFeeLevels {
     }
 }
 exports.EthereumFeeLevels = EthereumFeeLevels;
-//# sourceMappingURL=EthereumFees.js.map
+//# sourceMappingURL=EthereumFeeLevels.js.map

package/lib/{api/common/MiscFees.d.ts → backend/fees/MiscFeeLevels.d.ts}

@@ -1,11 +1,11 @@
-import { Blockchain } from '../../backend/BlockchainLink';
 import type { CoinInfo, FeeLevel } from '../../types';
+import { Blockchain } from '../Blockchain';
 export type Blocks = Array<string | undefined>;
 export declare class MiscFeeLevels {
     coinInfo: CoinInfo;
     levels: FeeLevel[];
-    longTermFeeRate?: string;
     blocks: Blocks;
+    wasFetchedSuccessfully: boolean;
     constructor(coinInfo: CoinInfo);
     load(blockchain: Blockchain, request: Parameters<typeof blockchain.estimateFee>[0]): Promise<{
         feePerTx?: string | undefined;
@@ -19,4 +19,4 @@ export declare class MiscFeeLevels {
         feePerUnit: string;
     }[]>;
 }
-//# sourceMappingURL=MiscFees.d.ts.map
+//# sourceMappingURL=MiscFeeLevels.d.ts.map