fix(fees): gate RBF below-floor broadcast; tolerate non-JSON precise body

In RBF mode the custom field commits per keystroke and silently ignored below-floor or emptied values, leaving newFeeRate pinned to the last valid rate — so Broadcast fired a rate the user no longer saw. CustomFeeListItem gains an onInvalid callback (RBF-only); the cubit tracks customFeeBelowFloor (newFeeRate doubles as the init sentinel and can't be nulled) and broadcast refuses while it's set. A valid edit or the Fastest tile clears it.

FeesDatasource dropped a precise 200 whose body arrived as a JSON string (a self-hosted mempool sending text/plain), silently degrading to rounded recommended fees. It now jsonDecodes a string body before the Map check, falling back only when the string isn't JSON.

Also corrects the relativeFromAbsoluteAndVsize rounding comment (half rounds down on odd vsize; bias < 1 sat/kwu).

Author: ethicnology

lib/core/fees/data/fees_datasource.dart

@@ -1,3 +1,5 @@
+import 'dart:convert';
+
 import 'package:bb_mobile/core/errors/bull_exception.dart';
 import 'package:bb_mobile/core/fees/data/models/mempool_fees_model.dart';
 import 'package:bb_mobile/core/mempool/application/usecases/get_active_mempool_server_usecase.dart';
@@ -81,8 +83,18 @@ class FeesDatasource {
   Future<MempoolFeesModel?> _getFees(Dio http, String path) async {
     try {
       final resp = await http.get<dynamic>(path);
-      final data = resp.data;
-      if (resp.statusCode == 200 && data is Map<String, dynamic>) {
+      if (resp.statusCode != 200) return null;
+      var data = resp.data;
+      // Dio only auto-decodes when the server sends a JSON content-type. A
+      // working-but-misconfigured self-hosted mempool returning the body as
+      // text/plain would otherwise silently drop precise → recommended,
+      // losing the sub-1 sat/vByte rates this whole path exists for. Decode
+      // a string body before the Map check; a non-JSON string throws and is
+      // caught below (→ fallback).
+      if (data is String && data.isNotEmpty) {
+        data = jsonDecode(data);
+      }
+      if (data is Map<String, dynamic>) {
         return MempoolFeesModel.fromJson(data);
       }
       return null;

lib/core/fees/domain/fees_entity.dart

@@ -57,7 +57,10 @@ sealed class NetworkFee with _$NetworkFee {
   }) {
     assert(vsize > 0, 'vsize must be positive');
     // sat/kwu = (absoluteSats / vsize) * 250
-    //        = (absoluteSats * 250) / vsize, rounded half-up via integer math.
+    //        = (absoluteSats * 250) / vsize, rounded to nearest via integer
+    // math. The `vsize ~/ 2` bias term truncates on odd vsize, so an exact
+    // half rounds down there; the resulting bias is under 1 sat/kwu
+    // (< 0.004 sat/vByte), well inside the ±1 sat tolerance noted above.
     return RelativeFee((absoluteSats * 250 + vsize ~/ 2) ~/ vsize);
   }
 

lib/features/replace_by_fee/presentation/cubit.dart

@@ -70,6 +70,14 @@ class ReplaceByFeeCubit extends Cubit<ReplaceByFeeState> {
         return;
       }
 
+      // The custom field currently shows a below-floor/empty rate. newFeeRate
+      // still holds the last valid value, so without this guard Broadcast
+      // would fire the stale rate the user no longer sees.
+      if (state.customFeeBelowFloor) {
+        emit(state.copyWith(error: FeeRateTooLowError()));
+        return;
+      }
+
       final psbt = await bumpFeeUsecase.execute(
         walletId: originalTransaction.walletId,
         txid: originalTransaction.txId,
@@ -92,5 +100,14 @@ class ReplaceByFeeCubit extends Cubit<ReplaceByFeeState> {
     }
   }
 
-  void onChangeFee(FeeEntity fee) => emit(state.copyWith(newFeeRate: fee));
+  /// A valid (above-floor) selection — from a custom keystroke or the Fastest
+  /// tile. Clears any prior below-floor flag.
+  void onChangeFee(FeeEntity fee) =>
+      emit(state.copyWith(newFeeRate: fee, customFeeBelowFloor: false));
+
+  /// The custom field went below the relay floor or was emptied. Keep
+  /// [newFeeRate] (the last valid value / init sentinel) but flag the field so
+  /// [broadcast] refuses the stale rate.
+  void markCustomFeeBelowFloor() =>
+      emit(state.copyWith(customFeeBelowFloor: true));
 }

lib/features/replace_by_fee/presentation/state.dart

@@ -11,6 +11,13 @@ sealed class ReplaceByFeeState with _$ReplaceByFeeState {
     @Default(null) ReplaceByFeeError? error,
     @Default(null) FeeEntity? fastestFeeRate,
     @Default(null) FeeEntity? newFeeRate,
+
+    /// True while the custom bump field holds a below-floor or empty/invalid
+    /// rate. [newFeeRate] still pins the last valid value (it doubles as the
+    /// "init complete" sentinel — nulling it would collapse the screen), so
+    /// this flag is what blocks [broadcast] from firing the stale rate while
+    /// the field shows a rejected value.
+    @Default(false) bool customFeeBelowFloor,
     @Default(null) String? txid,
 
     /// Live relay floor (mempool `minimumFee`, clamped to 0.1) so the custom

lib/features/replace_by_fee/ui/fee_selector_widget.dart

@@ -14,6 +14,7 @@ class BumpFeeSelectorWidget extends StatelessWidget {
     required this.selected,
     required this.txSize,
     required this.onChanged,
+    required this.onInvalid,
     required this.focusNode,
     this.minRelay,
   });
@@ -22,6 +23,10 @@ class BumpFeeSelectorWidget extends StatelessWidget {
   final FeeEntity selected;
   final int txSize;
   final void Function(FeeEntity fee) onChanged;
+
+  /// Called when the custom bump field goes below the relay floor or is
+  /// emptied — see [CustomFeeListItem.onInvalid].
+  final VoidCallback onInvalid;
   final FocusNode focusNode;
 
   /// Live relay floor for the custom bump field (null → static 0.1).
@@ -59,6 +64,7 @@ class BumpFeeSelectorWidget extends StatelessWidget {
               allowAbsoluteToggle: false,
               commitOnChange: true,
               focusNode: focusNode,
+              onInvalid: onInvalid,
               onCommit: (fee) async {
                 // Safe cast: allowAbsoluteToggle is false so the widget
                 // only ever produces a RelativeFee here.

lib/features/replace_by_fee/ui/home_page.dart

@@ -65,6 +65,7 @@ class _ReplaceByFeeHomePageState extends State<ReplaceByFeeHomePage> {
                       selected: state.newFeeRate!,
                       txSize: widget.tx.vsize,
                       onChanged: cubit.onChangeFee,
+                      onInvalid: cubit.markCustomFeeBelowFloor,
                       focusNode: _feeNode,
                       minRelay: state.minRelay,
                     ),

test/core_test/fees/fees_datasource_test.dart

@@ -168,6 +168,51 @@ void main() {
       verify(() => dio.get<dynamic>(_recommended)).called(1);
     });
 
+    test('parses a precise 200 whose body arrived as a JSON string', () async {
+      // A working-but-misconfigured self-hosted mempool can return the body as
+      // text/plain, so Dio leaves it undecoded as a String. We must still
+      // parse it (jsonDecode) and keep the sub-1 precision, not silently
+      // fall back to the rounded recommended endpoint.
+      when(() => dio.get<dynamic>(_precise)).thenAnswer(
+        (_) async => Response(
+          requestOptions: RequestOptions(path: _precise),
+          statusCode: 200,
+          data:
+              '{"fastestFee":1.203,"halfHourFee":0.92,"hourFee":0.65,'
+              '"economyFee":0.2,"minimumFee":0.1}',
+        ),
+      );
+
+      final fees = await datasource.fetchBitcoinNetworkFees(isTestnet: false);
+
+      expect(fees.fastestFee, 1.203);
+      expect(fees.hourFee, 0.65);
+      verifyNever(() => dio.get<dynamic>(_recommended));
+    });
+
+    test('falls back when a precise 200 string body is not JSON', () async {
+      when(() => dio.get<dynamic>(_precise)).thenAnswer(
+        (_) async => Response(
+          requestOptions: RequestOptions(path: _precise),
+          statusCode: 200,
+          data: '<html>maintenance</html>',
+        ),
+      );
+      when(() => dio.get<dynamic>(_recommended)).thenAnswer(
+        (_) async => _ok(_recommended, {
+          'fastestFee': 3,
+          'halfHourFee': 2,
+          'hourFee': 1,
+          'economyFee': 1,
+          'minimumFee': 1,
+        }),
+      );
+
+      final fees = await datasource.fetchBitcoinNetworkFees(isTestnet: false);
+      expect(fees.fastestFee, 3.0);
+      verify(() => dio.get<dynamic>(_recommended)).called(1);
+    });
+
     test('throws MempoolFeesException when both endpoints fail', () async {
       when(
         () => dio.get<dynamic>(_precise),

test/features/replace_by_fee/replace_by_fee_cubit_test.dart

@@ -0,0 +1,116 @@
+import 'package:bb_mobile/core/blockchain/domain/usecases/broadcast_bitcoin_transaction_usecase.dart';
+import 'package:bb_mobile/core/fees/domain/fees_entity.dart';
+import 'package:bb_mobile/core/fees/domain/get_network_fees_usecase.dart';
+import 'package:bb_mobile/core/wallet/domain/entities/wallet.dart';
+import 'package:bb_mobile/core/wallet/domain/entities/wallet_transaction.dart';
+import 'package:bb_mobile/features/replace_by_fee/domain/bump_fee_usecase.dart';
+import 'package:bb_mobile/features/replace_by_fee/domain/fee_entity.dart';
+import 'package:bb_mobile/features/replace_by_fee/errors.dart';
+import 'package:bb_mobile/features/replace_by_fee/presentation/cubit.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+
+class _MockBumpFee extends Mock implements BumpFeeUsecase {}
+
+class _MockBroadcast extends Mock
+    implements BroadcastBitcoinTransactionUsecase {}
+
+class _MockGetFees extends Mock implements GetNetworkFeesUsecase {}
+
+WalletTransaction _tx() => const WalletTransaction(
+  walletId: 'w1',
+  network: Network.bitcoinMainnet,
+  direction: WalletTransactionDirection.outgoing,
+  status: WalletTransactionStatus.pending,
+  txId: 'abc',
+  amountSat: 100000,
+  feeSat: 200,
+  vsize: 140,
+  inputs: [],
+  outputs: [],
+  isRbf: true,
+);
+
+FeeOptions _fees() => const FeeOptions(
+  fastest: RelativeFee(2000), // 8 sat/vB
+  economic: RelativeFee(500),
+  slow: RelativeFee(250),
+  minRelay: RelativeFee(25), // 0.1 sat/vB
+);
+
+void main() {
+  setUpAll(() {
+    registerFallbackValue(const RelativeFee(250));
+  });
+
+  late _MockBumpFee bumpFee;
+  late _MockBroadcast broadcast;
+  late _MockGetFees getFees;
+
+  Future<ReplaceByFeeCubit> buildCubit() async {
+    when(
+      () => getFees.execute(isLiquid: false),
+    ).thenAnswer((_) async => _fees());
+    final cubit = ReplaceByFeeCubit(
+      originalTransaction: _tx(),
+      bumpFeeUsecase: bumpFee,
+      broadcastBitcoinTransactionUsecase: broadcast,
+      getNetworkFeesUsecase: getFees,
+    );
+    // init() is async in the constructor — let it settle.
+    await Future<void>.delayed(Duration.zero);
+    return cubit;
+  }
+
+  setUp(() {
+    bumpFee = _MockBumpFee();
+    broadcast = _MockBroadcast();
+    getFees = _MockGetFees();
+  });
+
+  group('ReplaceByFeeCubit — below-floor selection gate', () {
+    test('broadcast refuses while the custom field is below floor', () async {
+      final cubit = await buildCubit();
+      // newFeeRate is seeded above floor by init(); the user then types a
+      // sub-floor rate, which the widget reports via markCustomFeeBelowFloor.
+      cubit.markCustomFeeBelowFloor();
+
+      await cubit.broadcast();
+
+      expect(cubit.state.error, isA<FeeRateTooLowError>());
+      verifyNever(
+        () => bumpFee.execute(
+          walletId: any(named: 'walletId'),
+          txid: any(named: 'txid'),
+          newFeeRate: any(named: 'newFeeRate'),
+        ),
+      );
+    });
+
+    test('a valid selection clears the flag and broadcast proceeds', () async {
+      final cubit = await buildCubit();
+      cubit.markCustomFeeBelowFloor();
+      // Re-typing a valid above-floor rate (or tapping Fastest) re-commits.
+      cubit.onChangeFee(
+        const FeeEntity(type: FeeType.custom, feeRate: RelativeFee(500)),
+      );
+      expect(cubit.state.customFeeBelowFloor, isFalse);
+
+      when(
+        () => bumpFee.execute(
+          walletId: any(named: 'walletId'),
+          txid: any(named: 'txid'),
+          newFeeRate: any(named: 'newFeeRate'),
+        ),
+      ).thenAnswer((_) async => 'psbt');
+      when(
+        () => broadcast.execute(any(), isPsbt: any(named: 'isPsbt')),
+      ).thenAnswer((_) async => 'txid-1');
+
+      await cubit.broadcast();
+
+      expect(cubit.state.txid, 'txid-1');
+      expect(cubit.state.error, isNull);
+    });
+  });
+}