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

import 'dart:math';

import 'package:flutter/foundation.dart';

import 'package:sxchnge_analytics/sxchnge_analytics.dart';

import 'package:sxchnge_auth/sxchnge_auth.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;
  FactorError? factorError;
  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;
    factorError = null;
    _key = null;
    _revision++;
    notifyListeners();
  }

  void edit() {
    if (!busy && !uncertain) {
      quote = null;
      error = null;
      factorError = 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;
    factorError = 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<FactorChallenge?> challenge() async {
    if (busy || uncertain || quote == null) return null;
    if (expired) {
      error = WalletError.expiredQuote;
      notifyListeners();
      return null;
    }
    busy = true;
    error = null;
    factorError = null;
    notifyListeners();
    FactorChallenge? result;
    final op = recorder.begin(
      journey,
      JourneyStep.factorChallenge,
      simulated: wallet.service.isSimulated,
    );
    try {
      result = await wallet.factors?.begin(
        FactorPurpose.values.byName(kind.name),
        quote!.id,
      );
    } catch (e) {
      if (!_disposed) {
        factorError = e is FactorException ? e.code : FactorError.unavailable;
      }
    }
    if (_disposed) return null;
    busy = false;
    notifyListeners();
    recorder.finish(
      op,
      simulated: wallet.service.isSimulated,
      failure: factorError == null ? null : JourneyFailure.unavailable,
    );
    return result;
  }

  Future<void> submit({FactorGrant? approval}) async {
    if (busy || quote == null || uncertain) return;
    if (expired) {
      error = WalletError.expiredQuote;
      notifyListeners();
      return;
    }
    busy = true;
    noSubmission = false;
    error = null;
    factorError = 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!,
        approval: approval?.token,
      );
      if (_disposed) return;
      _accepted(r, op);
    } catch (e) {
      if (_disposed) return;
      if (e is FactorException) {
        error = null;
        factorError = e.code;
        uncertain = false;
      } else {
        error = _code(e);
      }
      // All transport/unexpected failures are ambiguous after execution started.
      uncertain = [
        WalletError.unavailable,
        WalletError.uncertain,
      ].contains(error);
      recorder.finish(
        op,
        failure: error == null ? JourneyFailure.invalid : _failure(error!),
      );
    }
    if (_disposed) return;
    busy = false;
    notifyListeners();
  }

  void _accepted(WalletOperation value, JourneyOperation op) {
    result = value;
    uncertain = false;
    error = null;
    factorError = 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;
    factorError = 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();
  }
}