refactor(swaps): move auto swap settings rules onto the entity

Author: wired-pasteque

lib/core/swaps/domain/entity/auto_swap.dart

@@ -3,6 +3,15 @@ import 'package:freezed_annotation/freezed_annotation.dart';
 part 'auto_swap.freezed.dart';
 part 'auto_swap.g.dart';
 
+/// Which rule a set of auto swap settings breaks, in the order they are
+/// checked. Callers map this to whatever they show the user.
+enum AutoSwapSettingsViolation {
+  recipientWalletMissing,
+  balanceThresholdTooLow,
+  triggerBalanceTooLow,
+  feeThresholdTooHigh,
+}
+
 @freezed
 sealed class AutoSwap with _$AutoSwap {
   const factory AutoSwap({
@@ -21,6 +30,54 @@ sealed class AutoSwap with _$AutoSwap {
   factory AutoSwap.fromJson(Map<String, dynamic> json) =>
       _$AutoSwapFromJson(json);
 
+  /// Below this a swap would move less than it costs in fees.
+  static const int minimumBalanceThresholdSats = 50000;
+
+  /// Accepting a fee ceiling above this is almost certainly a mistake.
+  static const int maximumFeeThresholdPercent = 10;
+
+  /// Applied when a fee ceiling cannot be determined.
+  static const double defaultFeeThresholdPercent = 3.0;
+
+  static bool isBalanceThresholdTooLow(int balanceThresholdSats) =>
+      balanceThresholdSats < minimumBalanceThresholdSats;
+
+  /// A swap has to leave the wallet at its target, so the trigger must be at
+  /// least twice the target — otherwise a swap would fire and immediately
+  /// leave the balance below where it started.
+  static bool isTriggerBalanceTooLow({
+    required int balanceThresholdSats,
+    required int triggerBalanceSats,
+  }) => triggerBalanceSats < 2 * balanceThresholdSats;
+
+  static bool isFeeThresholdTooHigh(double feeThresholdPercent) =>
+      feeThresholdPercent > maximumFeeThresholdPercent;
+
+  /// The first rule these settings break, or null when they are acceptable.
+  ///
+  /// Deliberately not enforced in the constructor: these settings are
+  /// persisted and deserialized, so a row written by an older version must
+  /// still load even if it would no longer be accepted.
+  AutoSwapSettingsViolation? get violation {
+    // Only required while enabled: switching auto swap off needs no recipient.
+    if (enabled && recipientWalletId == null) {
+      return AutoSwapSettingsViolation.recipientWalletMissing;
+    }
+    if (isBalanceThresholdTooLow(balanceThresholdSats)) {
+      return AutoSwapSettingsViolation.balanceThresholdTooLow;
+    }
+    if (isTriggerBalanceTooLow(
+      balanceThresholdSats: balanceThresholdSats,
+      triggerBalanceSats: triggerBalanceSats,
+    )) {
+      return AutoSwapSettingsViolation.triggerBalanceTooLow;
+    }
+    if (isFeeThresholdTooHigh(feeThresholdPercent)) {
+      return AutoSwapSettingsViolation.feeThresholdTooHigh;
+    }
+    return null;
+  }
+
   bool passedRequiredBalance(int balanceSat) {
     return balanceSat >= triggerBalanceSats && enabled;
   }

test/core_test/swaps/auto_swap_test.dart

@@ -0,0 +1,104 @@
+import 'package:bb_mobile/core/swaps/domain/entity/auto_swap.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+/// Settings that break no rule, for tests to bend one field at a time.
+const _valid = AutoSwap(
+  enabled: true,
+  balanceThresholdSats: 100000,
+  triggerBalanceSats: 200000,
+  feeThresholdPercent: 3,
+  recipientWalletId: 'wallet-id',
+);
+
+void main() {
+  group('AutoSwap.violation', () {
+    test('accepts settings that break no rule', () {
+      expect(_valid.violation, isNull);
+    });
+
+    test('requires a recipient wallet only while enabled', () {
+      expect(
+        _valid.copyWith(recipientWalletId: null).violation,
+        AutoSwapSettingsViolation.recipientWalletMissing,
+      );
+
+      // Switching auto swap off must not demand a recipient, or turning the
+      // feature off would be impossible.
+      expect(
+        _valid.copyWith(enabled: false, recipientWalletId: null).violation,
+        isNull,
+      );
+    });
+
+    test('rejects a target balance below the minimum', () {
+      expect(
+        _valid.copyWith(balanceThresholdSats: 49999).violation,
+        AutoSwapSettingsViolation.balanceThresholdTooLow,
+      );
+      expect(
+        _valid
+            .copyWith(balanceThresholdSats: 50000, triggerBalanceSats: 100000)
+            .violation,
+        isNull,
+      );
+    });
+
+    test('rejects a trigger balance below twice the target', () {
+      expect(
+        _valid.copyWith(triggerBalanceSats: 199999).violation,
+        AutoSwapSettingsViolation.triggerBalanceTooLow,
+      );
+      expect(_valid.copyWith(triggerBalanceSats: 200000).violation, isNull);
+    });
+
+    test('rejects a fee ceiling above the maximum', () {
+      expect(
+        _valid.copyWith(feeThresholdPercent: 10.1).violation,
+        AutoSwapSettingsViolation.feeThresholdTooHigh,
+      );
+      expect(_valid.copyWith(feeThresholdPercent: 10).violation, isNull);
+    });
+
+    test('reports the recipient rule before the amount rules', () {
+      final broken = _valid.copyWith(
+        recipientWalletId: null,
+        balanceThresholdSats: 1,
+        triggerBalanceSats: 1,
+        feeThresholdPercent: 99,
+      );
+
+      expect(
+        broken.violation,
+        AutoSwapSettingsViolation.recipientWalletMissing,
+      );
+    });
+
+    test('reports the balance rule before the trigger rule', () {
+      // Both broken; the target is the field the user must fix first.
+      expect(
+        _valid
+            .copyWith(balanceThresholdSats: 1000, triggerBalanceSats: 1)
+            .violation,
+        AutoSwapSettingsViolation.balanceThresholdTooLow,
+      );
+    });
+
+    test('a persisted row that breaks a rule still deserializes', () {
+      // The rules are not constructor-enforced on purpose: settings written by
+      // an older version must still load, or the feature becomes unopenable.
+      final legacy = AutoSwap.fromJson(const {
+        'enabled': true,
+        'balanceThresholdSats': 10000,
+        'triggerBalanceSats': 15000,
+        'feeThresholdPercent': 50.0,
+        'blockTillNextExecution': false,
+        'alwaysBlock': false,
+        'recipientWalletId': null,
+        'showWarning': true,
+      });
+
+      expect(legacy.balanceThresholdSats, 10000);
+      expect(legacy.violation, isNotNull);
+    });
+  });
+}