Build exchange workspace and shared transaction services (#28)

frontend/packages/sxchnge_wallet/lib/src/providers/transfer.dart

@@ -0,0 +1,213 @@
+import 'dart:math';
+
+import 'package:flutter/foundation.dart';
+
+import 'package:sxchnge_analytics/sxchnge_analytics.dart';
+
+import '../models/wallet.dart';
+import 'wallet.dart';
+
+class TransferProvider extends ChangeNotifier {
+  TransferProvider(this.wallet, this.kind, {String? source})
+    : source = source ?? wallet.data?.accounts.firstOrNull?.id ?? 'eur',
+      recorder = JourneyRecorder(wallet.analytics) {
+    destination =
+        wallet.data?.accounts
+            .where((a) => a.id != this.source)
+            .firstOrNull
+            ?.id ??
+        'usd';
+    final op = recorder.begin(
+      journey,
+      JourneyStep.transferDraft,
+      simulated: wallet.service.isSimulated,
+    );
+    recorder.finish(op, simulated: wallet.service.isSimulated);
+  }
+  final WalletProvider wallet;
+  final TransferKind kind;
+  final JourneyRecorder recorder;
+  String source;
+  String? destination;
+  String amount = '', recipient = '';
+  Quote? quote;
+  WalletOperation? result;
+  WalletError? error;
+  bool noSubmission = false;
+  bool busy = false, uncertain = false, _disposed = false, _handedOff = false;
+  int _revision = 0;
+  String? _key;
+  JourneyKind get journey => switch (kind) {
+    TransferKind.topUp => JourneyKind.topUp,
+    TransferKind.exchange => JourneyKind.exchange,
+    TransferKind.payout => JourneyKind.payout,
+  };
+  bool get hasDraft => amount.isNotEmpty || recipient.isNotEmpty;
+  bool get expired =>
+      quote != null && !DateTime.now().isBefore(quote!.expiresAt);
+  void change({
+    String? source,
+    String? destination,
+    String? amount,
+    String? recipient,
+  }) {
+    if (busy || uncertain) return;
+    this.source = source ?? this.source;
+    this.destination = destination ?? this.destination;
+    this.amount = amount ?? this.amount;
+    this.recipient = recipient ?? this.recipient;
+    quote = null;
+    noSubmission = false;
+    error = null;
+    _key = null;
+    _revision++;
+    notifyListeners();
+  }
+
+  void edit() {
+    if (!busy && !uncertain) {
+      quote = null;
+      error = null;
+      _key = null;
+      notifyListeners();
+    }
+  }
+
+  Future<void> review() async {
+    if (busy || uncertain) return;
+    final money = wallet.account(source)?.parse(amount);
+    if (money == null || money <= 0) {
+      error = WalletError.invalidAmount;
+      notifyListeners();
+      return;
+    }
+    busy = true;
+    noSubmission = false;
+    error = null;
+    notifyListeners();
+    final revision = ++_revision;
+    final op = recorder.begin(
+      journey,
+      JourneyStep.transferQuote,
+      simulated: wallet.service.isSimulated,
+    );
+    try {
+      final q = await wallet.service.quote(
+        TransferRequest(
+          kind: kind,
+          source: source,
+          amount: money,
+          destination: kind == TransferKind.exchange ? destination : null,
+          recipient: recipient.trim(),
+        ),
+      );
+      if (_disposed || revision != _revision) return;
+      quote = q;
+      _key = null;
+      recorder.finish(op, simulated: wallet.service.isSimulated);
+    } catch (e) {
+      if (_disposed) return;
+      error = _code(e);
+      recorder.finish(op, failure: _failure(error!));
+    }
+    if (_disposed) return;
+    busy = false;
+    notifyListeners();
+  }
+
+  Future<void> submit() async {
+    if (busy || quote == null || uncertain) return;
+    if (expired) {
+      error = WalletError.expiredQuote;
+      notifyListeners();
+      return;
+    }
+    busy = true;
+    noSubmission = false;
+    error = null;
+    notifyListeners();
+    _key ??= List.generate(
+      16,
+      (_) => Random.secure().nextInt(256).toRadixString(16).padLeft(2, '0'),
+    ).join();
+    final op = recorder.begin(
+      journey,
+      JourneyStep.transferSubmission,
+      simulated: wallet.service.isSimulated,
+    );
+    try {
+      final r = await wallet.service.submit(quote!.id, _key!);
+      if (_disposed) return;
+      _accepted(r, op);
+    } catch (e) {
+      if (_disposed) return;
+      error = _code(e);
+      // All transport/unexpected failures are ambiguous after execution started.
+      uncertain = [
+        WalletError.unavailable,
+        WalletError.uncertain,
+      ].contains(error);
+      recorder.finish(op, failure: _failure(error!));
+    }
+    if (_disposed) return;
+    busy = false;
+    notifyListeners();
+  }
+
+  void _accepted(WalletOperation value, JourneyOperation op) {
+    result = value;
+    uncertain = false;
+    error = null;
+    recipient = '';
+    recorder.finish(op, simulated: wallet.service.isSimulated);
+    wallet.track(value, recorder, journey);
+    _handedOff = true;
+  }
+
+  Future<void> reconcile() async {
+    if (busy || !uncertain || _key == null) return;
+    busy = true;
+    noSubmission = false;
+    error = null;
+    notifyListeners();
+    final op = recorder.begin(
+      journey,
+      JourneyStep.transferSubmission,
+      simulated: wallet.service.isSimulated,
+    );
+    try {
+      final r = await wallet.service.findSubmission(_key!);
+      if (_disposed) return;
+      if (r != null) {
+        _accepted(r, op);
+      } else {
+        uncertain = false;
+        noSubmission = true;
+        recorder.finish(op, simulated: wallet.service.isSimulated);
+      }
+    } catch (e) {
+      if (_disposed) return;
+      error = _code(e);
+      recorder.finish(op, failure: JourneyFailure.unavailable);
+    }
+    if (_disposed) return;
+    busy = false;
+    notifyListeners();
+  }
+
+  WalletError _code(Object e) =>
+      e is WalletException ? e.code : WalletError.unavailable;
+  JourneyFailure _failure(WalletError e) => switch (e) {
+    WalletError.insufficientFunds => JourneyFailure.insufficientFunds,
+    WalletError.limitExceeded => JourneyFailure.limitExceeded,
+    WalletError.expiredQuote => JourneyFailure.expired,
+    _ => JourneyFailure.unavailable,
+  };
+  @override
+  void dispose() {
+    _disposed = true;
+    recipient = '';
+    if (!_handedOff) recorder.dispose();
+    super.dispose();
+  }
+}