fix: 🐛 Libdart compatibility

l10n.yaml

@@ -1,3 +1,4 @@
 arb-dir: lib/l10n
 template-arb-file: intl_en.arb
 output-localization-file: localizations.dart
+untranslated-messages-file: untranslated_messages.txt

lib/application/aeswap/dex_token.dart

@@ -83,10 +83,10 @@ Future<double> _estimateTokenInFiat(
   String tokenAddress,
 ) async {
   if (tokenAddress.isUCO) {
-    return ref.watch(
-      aedappfm.ArchethicOracleUCOProviders.archethicOracleUCO
-          .select((value) => value.usd),
-    );
+    return (await ref.watch(
+      aedappfm.ArchethicOracleUCOProviders.archethicOracleUCO.future,
+    ))
+        .usd;
   } else {
     final environment = ref.watch(environmentProvider);
     return await ref.watch(

lib/application/market_price.dart

@@ -40,8 +40,9 @@ Future<MarketPrice> _currencyMarketPrice(
 Future<MarketPrice> _selectedCurrencyMarketPrice(
   Ref ref,
 ) async {
-  final archethicOracleUCO =
-      ref.watch(aedappfm.ArchethicOracleUCOProviders.archethicOracleUCO);
+  final archethicOracleUCO = await ref.watch(
+    aedappfm.ArchethicOracleUCOProviders.archethicOracleUCO.future,
+  );
   return MarketPrice(
     amount: archethicOracleUCO.usd,
     lastLoading: archethicOracleUCO.timestamp,

lib/domain/repositories/transaction_remote.dart

@@ -9,11 +9,9 @@ import 'package:aewallet/model/data/account.dart';
 import 'package:archethic_lib_dart/archethic_lib_dart.dart' as archethic;
 
 typedef TransactionConfirmationHandler = Future<void> Function(
-  archethic.TransactionSenderInterface sender,
   archethic.TransactionConfirmation confirmation,
 );
 typedef TransactionErrorHandler = Future<void> Function(
-  archethic.TransactionSenderInterface sender,
   archethic.TransactionError error,
 );
 
@@ -22,11 +20,16 @@ abstract class TransactionRemoteRepositoryInterface {
 
   Future<Result<double, Failure>> calculateFees(Transaction transaction);
 
-  Future<void> send({
+  Future<archethic.TransactionConfirmation?> send({
     required Transaction transaction,
     Duration timeout = const Duration(seconds: 10),
-    required TransactionConfirmationHandler onConfirmation,
-    required TransactionErrorHandler onError,
+    TransactionConfirmationHandler? onConfirmation,
+  });
+
+  Future<archethic.TransactionConfirmation?> sendSignedRaw({
+    required archethic.Transaction transaction,
+    Duration timeout = const Duration(seconds: 10),
+    TransactionConfirmationHandler? onConfirmation,
   });
 
   Future<archethic.Transaction> buildTransactionRaw(
@@ -36,13 +39,6 @@ abstract class TransactionRemoteRepositoryInterface {
     String serviceName,
   );
 
-  Future<void> sendSignedRaw({
-    required archethic.Transaction transactionSignedRaw,
-    Duration timeout = const Duration(seconds: 10),
-    required TransactionConfirmationHandler onConfirmation,
-    required TransactionErrorHandler onError,
-  });
-
   Future<String?> getLastTransactionAddress({
     required String genesisAddress,
   });

lib/domain/usecases/aeswap/add_liquidity.usecase.dart

@@ -2,7 +2,6 @@
 import 'dart:async';
 
 import 'package:aewallet/domain/repositories/transaction_remote.dart';
-import 'package:aewallet/domain/repositories/transaction_validation_ratios.dart';
 import 'package:aewallet/model/blockchain/keychain_secured_infos.dart';
 import 'package:aewallet/model/data/account.dart';
 import 'package:aewallet/modules/aeswap/application/contracts/archethic_contract.dart';
@@ -95,67 +94,57 @@ class AddLiquidityCase with aedappfm.TransactionMixin {
 
       liquidityAddNotifier.setTransactionAddLiquidity(transationSignedRaw);
 
-      await transactionRepository.sendSignedRaw(
-        transactionSignedRaw: transationSignedRaw,
-        onConfirmation: (sender, confirmation) async {
-          if (archethic.TransactionConfirmation.isEnoughConfirmations(
-            confirmation.nbConfirmations,
-            confirmation.maxConfirmations,
-            TransactionValidationRatios.addLiquidity,
-          )) {
-            sender.close();
+      final confirmation = await transactionRepository.sendSignedRaw(
+        transaction: transationSignedRaw,
+      );
 
-            liquidityAddNotifier
-              ..setResumeProcess(false)
-              ..setProcessInProgress(false)
-              ..setLiquidityAddOk(true);
+      if (confirmation == null) return;
+      liquidityAddNotifier
+        ..setResumeProcess(false)
+        ..setLiquidityAddOk(true);
 
-            notificationService.start(
-              operationId,
-              DexNotification.addLiquidity(
-                txAddress: transationSignedRaw.address!.address,
-              ),
-            );
+      notificationService.start(
+        operationId,
+        DexNotification.addLiquidity(
+          txAddress: transationSignedRaw.address!.address,
+        ),
+      );
 
-            final amount = await aedappfm.PeriodicFuture.periodic<double>(
-              () => getAmountFromTxInput(
-                transationSignedRaw.address!.address!,
-                lpToken.address,
-                apiService,
-              ),
-              sleepDuration: const Duration(seconds: 3),
-              until: (amount) => amount > 0,
-              timeout: const Duration(minutes: 1),
-            );
+      final amount = await aedappfm.PeriodicFuture.periodic<double>(
+        () => getAmountFromTxInput(
+          transationSignedRaw.address!.address!,
+          lpToken.address,
+          apiService,
+        ),
+        sleepDuration: const Duration(seconds: 3),
+        until: (amount) => amount > 0,
+        timeout: const Duration(minutes: 1),
+      );
 
-            liquidityAddNotifier.setFinalAmount(amount);
+      liquidityAddNotifier.setFinalAmount(amount);
 
-            notificationService.succeed(
-              operationId,
-              DexNotification.addLiquidity(
-                txAddress: transationSignedRaw.address!.address,
-                lpToken: lpToken,
-                amount: amount,
-              ),
-            );
-          }
-        },
-        onError: (sender, error) async {
-          notificationService.failed(
-            operationId,
-            aedappfm.Failure.fromError(error.messageLabel),
-          );
-          liquidityAddNotifier
-            ..setResumeProcess(false)
-            ..setProcessInProgress(false)
-            ..setLiquidityAddOk(false)
-            ..setFailure(
-              aedappfm.Failure.other(
-                cause: error.messageLabel.capitalize(),
-              ),
-            );
-        },
+      notificationService.succeed(
+        operationId,
+        DexNotification.addLiquidity(
+          txAddress: transationSignedRaw.address!.address,
+          lpToken: lpToken,
+          amount: amount,
+        ),
+      );
+    } on archethic.TransactionError catch (error) {
+      notificationService.failed(
+        operationId,
+        aedappfm.Failure.fromError(error.messageLabel),
       );
+      liquidityAddNotifier
+        ..setResumeProcess(false)
+        ..setProcessInProgress(false)
+        ..setLiquidityAddOk(false)
+        ..setFailure(
+          aedappfm.Failure.other(
+            cause: error.messageLabel.capitalize(),
+          ),
+        );
     } catch (e) {
       liquidityAddNotifier
         ..setResumeProcess(false)

lib/domain/usecases/aeswap/claim_farm_lock.usecase.dart

@@ -1,7 +1,7 @@
 /// SPDX-License-Identifier: AGPL-3.0-or-later
 import 'dart:async';
+
 import 'package:aewallet/domain/repositories/transaction_remote.dart';
-import 'package:aewallet/domain/repositories/transaction_validation_ratios.dart';
 import 'package:aewallet/model/blockchain/keychain_secured_infos.dart';
 import 'package:aewallet/model/data/account.dart';
 import 'package:aewallet/modules/aeswap/application/contracts/archethic_contract.dart';
@@ -91,78 +91,68 @@ class ClaimFarmLockCase with aedappfm.TransactionMixin {
         transationSignedRaw,
       );
 
-      await transactionRepository.sendSignedRaw(
-        transactionSignedRaw: transationSignedRaw,
-        onConfirmation: (sender, confirmation) async {
-          if (archethic.TransactionConfirmation.isEnoughConfirmations(
-            confirmation.nbConfirmations,
-            confirmation.maxConfirmations,
-            TransactionValidationRatios.claimFarmLock,
-          )) {
-            sender.close();
-
-            farmClaimLockNotifier
-              ..setResumeProcess(false)
-              ..setProcessInProgress(false)
-              ..setFarmLockClaimOk(true);
-
-            notificationService.start(
-              operationId,
-              DexNotification.claimFarmLock(
-                txAddress: transationSignedRaw.address!.address,
-              ),
-            );
+      final confirmation = await transactionRepository.sendSignedRaw(
+        transaction: transationSignedRaw,
+      );
 
-            await aedappfm.PeriodicFuture.periodic<bool>(
-              () => isSCCallExecuted(
-                apiService,
-                farmGenesisAddress,
-                transationSignedRaw.address!.address!,
-              ),
-              sleepDuration: const Duration(seconds: 3),
-              until: (depositOk) => depositOk == true,
-              timeout: const Duration(minutes: 1),
-            );
+      if (confirmation == null) return;
+      farmClaimLockNotifier
+        ..setResumeProcess(false)
+        ..setFarmLockClaimOk(true);
 
-            final amount = await aedappfm.PeriodicFuture.periodic<double>(
-              () => getAmountFromTxInput(
-                transationSignedRaw.address!.address!,
-                rewardToken.address,
-                apiService,
-              ),
-              sleepDuration: const Duration(seconds: 3),
-              until: (amount) => amount > 0,
-              timeout: const Duration(minutes: 1),
-            );
+      notificationService.start(
+        operationId,
+        DexNotification.claimFarmLock(
+          txAddress: transationSignedRaw.address!.address,
+        ),
+      );
 
-            farmClaimLockNotifier.setFinalAmount(amount);
+      await aedappfm.PeriodicFuture.periodic<bool>(
+        () => isSCCallExecuted(
+          apiService,
+          farmGenesisAddress,
+          transationSignedRaw.address!.address!,
+        ),
+        sleepDuration: const Duration(seconds: 3),
+        until: (depositOk) => depositOk == true,
+        timeout: const Duration(minutes: 1),
+      );
 
-            notificationService.succeed(
-              operationId,
-              DexNotification.claimFarmLock(
-                txAddress: transationSignedRaw.address!.address,
-                amount: amount,
-                rewardToken: rewardToken,
-              ),
-            );
-          }
-        },
-        onError: (sender, error) async {
-          notificationService.failed(
-            operationId,
-            aedappfm.Failure.fromError(error.messageLabel),
-          );
-          farmClaimLockNotifier
-            ..setResumeProcess(false)
-            ..setProcessInProgress(false)
-            ..setFarmLockClaimOk(false)
-            ..setFailure(
-              aedappfm.Failure.other(
-                cause: error.messageLabel.capitalize(),
-              ),
-            );
-        },
+      final amount = await aedappfm.PeriodicFuture.periodic<double>(
+        () => getAmountFromTxInput(
+          transationSignedRaw.address!.address!,
+          rewardToken.address,
+          apiService,
+        ),
+        sleepDuration: const Duration(seconds: 3),
+        until: (amount) => amount > 0,
+        timeout: const Duration(minutes: 1),
       );
+
+      farmClaimLockNotifier.setFinalAmount(amount);
+
+      notificationService.succeed(
+        operationId,
+        DexNotification.claimFarmLock(
+          txAddress: transationSignedRaw.address!.address,
+          amount: amount,
+          rewardToken: rewardToken,
+        ),
+      );
+    } on archethic.TransactionError catch (error) {
+      notificationService.failed(
+        operationId,
+        aedappfm.Failure.fromError(error.messageLabel),
+      );
+      farmClaimLockNotifier
+        ..setResumeProcess(false)
+        ..setProcessInProgress(false)
+        ..setFarmLockClaimOk(false)
+        ..setFailure(
+          aedappfm.Failure.other(
+            cause: error.messageLabel.capitalize(),
+          ),
+        );
     } catch (e) {
       farmClaimLockNotifier
         ..setResumeProcess(false)