refactor(fees): extract preview use cases and cache value object

Unifies the fee-preview state machine that was duplicated between
SendCubit and TransferBloc — same parallel build with rate-dedupe,
same custom-rate debounce, same 11 nullable cache fields, identical
0.1-floor check.

New primitives in lib/core/fees/domain/:
- BitcoinFeePreviewSlot + BitcoinFeePreviewCache value objects
  collapse the 11 nullable fields per state into one composite keyed
  by FeeSelection.
- NetworkFeeRelayPolicy with a single minRelay constant.
- BitcoinFeePresetPolicy owns the Slow-pin (0.1 sat/vB) decision
  instead of FeesDatasource.

New use cases in lib/features/send/domain/usecases/ (swap imports
them via the same pre-existing pattern it uses for
PrepareBitcoinSendUsecase):
- PreviewBitcoinFeeUsecase builds one PSBT and reports the real
  psbt.fee() + cached bytes.
- PreviewBitcoinFeePresetsUsecase builds fastest/economic/slow in
  parallel and dedupes by rate — same-rate presets share one PSBT so
  a quiet mempool can't make Slow look more expensive than Economic.

Behaviour fixes folded in:
- Use case logs build failures instead of silently swallowing them.
- The custom-fee tile prefills the input with the previously
  committed value on reopen.
- L10n key sendEstimatedDeliveryFewHours renamed to
  sendEstimatedDeliveryHours; English value is now "hours". Other
  locales keep their pre-rename strings (translation follow-up).

3 new test files cover the slot/cache invariants, the minRelay
policy boundary, and the preset-policy slow-pin. Widget tests gain
3 prefill cases. 192 tests pass; analyze --fatal-warnings
--fatal-infos clean.

Deferred:
- Single-modal widget unification across send/swap — needs careful
  bloc-provider rewiring with a manual smoke test.
- Moving PrepareBitcoinSendUsecase + CalculateBitcoinAbsoluteFees-
  Usecase to lib/core/wallet/ to fix the pre-existing swap → send
  feature-isolation violation.
- Translating "hours" into the 25 non-English locales.

Author: ethicnology

lib/core/fees/data/fees_datasource.dart

@@ -51,15 +51,12 @@ class FeesDatasource {
     final data = resp.data as Map<String, dynamic>;
     final fastestFee = data['fastestFee'] as int;
     final economyFee = data['economyFee'] as int;
-    final minimumFee = data['minimumFee'] as int;
 
-    final feeOptions = FeeOptions(
-      fastest: NetworkFee.relativeFromSatPerVbyte(fastestFee.toDouble()),
-      economic: NetworkFee.relativeFromSatPerVbyte(economyFee.toDouble()),
-      slow: NetworkFee.relativeFromSatPerVbyte(minimumFee.toDouble()),
+    // Policy lives in domain — datasource is pure HTTP + delegate.
+    return BitcoinFeePresetPolicy.fromMempool(
+      fastestSatPerVbyte: fastestFee.toDouble(),
+      economicSatPerVbyte: economyFee.toDouble(),
     );
-
-    return feeOptions;
   }
 
   Future<FeeOptions> getLiquidNetworkFeeOptions({

lib/core/fees/domain/fee_preview_cache.dart

@@ -0,0 +1,69 @@
+import 'package:bb_mobile/core/fees/domain/fees_entity.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'fee_preview_cache.freezed.dart';
+
+/// One slot of the four-tile fee-preview cache. Holds the real fee read
+/// from a built unsigned PSBT (`psbt.fee()`), plus the PSBT bytes and
+/// txSize so the commit path can rebroadcast the exact tx the user saw
+/// — defeating BDK's randomized coin selection.
+///
+/// An empty slot (`feeSat == null && unsignedPsbt == null && txSize == null`)
+/// means the modal has not built this preset for the current input shape
+/// yet; the UI shimmers.
+@freezed
+abstract class BitcoinFeePreviewSlot with _$BitcoinFeePreviewSlot {
+  const factory BitcoinFeePreviewSlot({
+    int? feeSat,
+    String? unsignedPsbt,
+    int? txSize,
+  }) = _BitcoinFeePreviewSlot;
+  const BitcoinFeePreviewSlot._();
+
+  /// Whether this slot can be reused at commit time. Both PSBT and txSize
+  /// must be present — `feeSat` alone is a display value, not enough to
+  /// short-circuit the build.
+  bool get isCacheReady => unsignedPsbt != null && txSize != null;
+}
+
+/// The full four-slot fee-preview cache, plus the two loading flags the
+/// UI shimmers off. Replaces 11 nullable fields on `SendState` /
+/// `TransferState` with one composite value object so the cache lifecycle
+/// is reasonable about and the matrix of partial states stops bleeding
+/// through state.copyWith calls.
+///
+/// Indexed by [FeeSelection]; both states expose `state.feePreviewCache`
+/// to selectors and read slots via [slotFor].
+@freezed
+abstract class BitcoinFeePreviewCache with _$BitcoinFeePreviewCache {
+  const factory BitcoinFeePreviewCache({
+    @Default(BitcoinFeePreviewSlot()) BitcoinFeePreviewSlot fastest,
+    @Default(BitcoinFeePreviewSlot()) BitcoinFeePreviewSlot economic,
+    @Default(BitcoinFeePreviewSlot()) BitcoinFeePreviewSlot slow,
+    @Default(BitcoinFeePreviewSlot()) BitcoinFeePreviewSlot custom,
+    @Default(false) bool presetsLoading,
+    @Default(false) bool customLoading,
+  }) = _BitcoinFeePreviewCache;
+  const BitcoinFeePreviewCache._();
+
+  /// Empty cache — no slot has been built. Use as the default on the
+  /// owning state and as the value to `copyWith` into on invalidation.
+  static const empty = BitcoinFeePreviewCache();
+
+  BitcoinFeePreviewSlot slotFor(FeeSelection selection) => switch (selection) {
+    FeeSelection.fastest => fastest,
+    FeeSelection.economic => economic,
+    FeeSelection.slow => slow,
+    FeeSelection.custom => custom,
+  };
+
+  BitcoinFeePreviewCache withSlot(
+    FeeSelection selection,
+    BitcoinFeePreviewSlot slot,
+  ) => switch (selection) {
+    FeeSelection.fastest => copyWith(fastest: slot),
+    FeeSelection.economic => copyWith(economic: slot),
+    FeeSelection.slow => copyWith(slow: slot),
+    FeeSelection.custom => copyWith(custom: slot),
+  };
+}

lib/core/fees/domain/fees_entity.dart

@@ -1,4 +1,3 @@
-import 'package:bb_mobile/core/utils/amount_conversions.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 
 part 'fees_entity.freezed.dart';
@@ -96,6 +95,49 @@ extension RelativeFeeDisplay on RelativeFee {
   double get satPerKvbyte => satPerKwu * 4.0;
 }
 
+/// Minimum-relay policy for transaction fees — single source of truth used
+/// by the cubit/bloc commit gates, the custom-fee widget's "below floor"
+/// banner, and the slow-preset pin in [BitcoinFeePresetPolicy]. The value
+/// matches both Bitcoin Core's lowest sensible relay policy and Liquid's
+/// network minrelayfee, so the same constant is correct on both chains.
+extension NetworkFeeRelayPolicy on NetworkFee {
+  /// 0.1 sat/vByte = 25 sat/kwu, exact.
+  static const double minRelaySatPerVbyte = 0.1;
+  static const int minRelaySatPerKwu = 25;
+
+  /// True when this fee is at or above the network minrelayfee. Absolute
+  /// fees need a [txSize] to express as a rate; [txSize] ≤ 0 → false (the
+  /// caller is in a transient pre-build state and shouldn't be allowed to
+  /// commit yet).
+  bool aboveMinRelay({int? txSize}) => switch (this) {
+    RelativeFee(:final satPerKwu) => satPerKwu >= minRelaySatPerKwu,
+    AbsoluteFee(:final sats) =>
+      txSize != null && txSize > 0 && (sats / txSize) >= minRelaySatPerVbyte,
+  };
+}
+
+/// Maps a mempool API response into the three preset tiers. Slow is pinned
+/// to the network minrelayfee instead of mempool's `minimumFee` — the whole
+/// point of #2133 was to offer a real sub-1 sat/vByte slot for users
+/// willing to wait, which `minimumFee` (typically 1 at quiet blocks) defeats.
+class BitcoinFeePresetPolicy {
+  const BitcoinFeePresetPolicy._();
+
+  /// Constructs the preset triple from the two mempool fields we still
+  /// trust. `fastestFee` and `economyFee` come straight from the API;
+  /// `slow` is pinned to [NetworkFeeRelayPolicy.minRelaySatPerVbyte].
+  static FeeOptions fromMempool({
+    required double fastestSatPerVbyte,
+    required double economicSatPerVbyte,
+  }) => FeeOptions(
+    fastest: NetworkFee.relativeFromSatPerVbyte(fastestSatPerVbyte),
+    economic: NetworkFee.relativeFromSatPerVbyte(economicSatPerVbyte),
+    slow: NetworkFee.relativeFromSatPerVbyte(
+      NetworkFeeRelayPolicy.minRelaySatPerVbyte,
+    ),
+  );
+}
+
 @freezed
 abstract class FeeOptions with _$FeeOptions {
   const factory FeeOptions({
@@ -128,52 +170,6 @@ abstract class FeeOptions with _$FeeOptions {
   }
 }
 
-extension FeeOptionsDisplay on FeeOptions {
-  List<(String, String, String)> display(
-    int txSize,
-    double exchangeRate,
-    String currencySymbol,
-  ) {
-    // Predictions only — preset tiles never have a real PSBT to read from
-    // (no commit happened yet). Use integer math via NetworkFee.toAbsolute
-    // so the line doesn't render IEEE-noisy doubles like 208.0 or
-    // 14.100000000000001. BDK may still pay 1-3 sats more at sub-1
-    // sat/vByte rates due to ceil + dust absorption — that's documented
-    // BDK behaviour we can't predict without building a real tx.
-    final fastestAbsSats = fastest.toAbsolute(txSize).value.toInt();
-    final economicAbsSats = economic.toAbsolute(txSize).value.toInt();
-    final slowAbsSats = slow.toAbsolute(txSize).value.toInt();
-    final fastestFiatEq = ConvertAmount.satsToFiat(
-      fastestAbsSats,
-      exchangeRate,
-    );
-    final economicFiatEq = ConvertAmount.satsToFiat(
-      economicAbsSats,
-      exchangeRate,
-    );
-    final slowFiatEq = ConvertAmount.satsToFiat(slowAbsSats, exchangeRate);
-    // `~` not `=` between rate and sat-count: the sat-count is a
-    // prediction (rate × vsize, integer-rounded). BDK pays 1-3 sats more
-    // at sub-1 sat/vByte due to ceil + sub-dust change absorption.
-    return [
-      (
-        'Fastest',
-        'Estimated delivery ~ 10 minutes',
-        '${fastest.value} sats/byte ~ $fastestAbsSats sats (~ $fastestFiatEq) $currencySymbol',
-      ),
-      (
-        'Economic',
-        'Estimated delivery ~ 30 minutes',
-        '${economic.value} sats/byte ~ $economicAbsSats sats (~ $economicFiatEq) $currencySymbol',
-      ),
-      (
-        'Slow',
-        'Estimated delivery ~ few hours',
-        '${slow.value} sats/byte ~ $slowAbsSats sats (~ $slowFiatEq) $currencySymbol',
-      ),
-    ];
-  }
-}
 
 enum FeeSelection { fastest, economic, slow, custom }
 

lib/core/widgets/dropdown/selectable_list.dart

@@ -1,4 +1,5 @@
 import 'package:bb_mobile/core/themes/app_theme.dart';
+import 'package:bb_mobile/core/widgets/loading/loading_line_content.dart';
 import 'package:bb_mobile/core/widgets/text/text.dart';
 import 'package:flutter/material.dart';
 import 'package:gap/gap.dart';
@@ -10,12 +11,19 @@ class SelectableListItem {
   final String subtitle2;
   final String value;
 
+  /// When true, [subtitle2] is hidden and replaced with a shimmer line —
+  /// used by fee preset tiles while the caller builds an unsigned PSBT
+  /// to read the real fee. Prevents the row from displaying its own
+  /// `rate × vsize` math while a real value is on the way.
+  final bool isSubtitle2Loading;
+
   const SelectableListItem({
     this.iconPath,
     required this.title,
     required this.subtitle1,
     required this.subtitle2,
     required this.value,
+    this.isSubtitle2Loading = false,
   });
 }
 
@@ -88,7 +96,17 @@ class _SelectableRow extends StatelessWidget {
                     const Gap(4),
                     BBText(item.subtitle1, style: context.font.labelMedium),
                     const Gap(2),
-                    BBText(item.subtitle2, style: context.font.labelMedium),
+                    if (item.isSubtitle2Loading)
+                      LoadingLineContent(
+                        width: 160,
+                        height: 12,
+                        padding: EdgeInsets.zero,
+                      )
+                    else
+                      BBText(
+                        item.subtitle2,
+                        style: context.font.labelMedium,
+                      ),
                   ],
                 ),
               ),