Merge branch 'main' of https://github.com/cake-tech/cake_wallet into mweb-bg-sync-2

cw_bitcoin/lib/litecoin_wallet.dart

@@ -393,7 +393,6 @@ abstract class LitecoinWalletBase extends ElectrumWallet with Store {
               // if the confirmations haven't changed, skip updating:
               if (tx.confirmations == confirmations) continue;
 
-              // print("updating confs ${tx.id} from ${tx.confirmations} -> $confirmations");
 
               // if an outgoing tx is now confirmed, delete the utxo from the box (delete the unspent coin):
               if (confirmations >= 2 &&

cw_bitcoin/pubspec.yaml

@@ -73,6 +73,7 @@ dependency_overrides:
 
 # The following section is specific to Flutter.
 flutter:
+    uses-material-design: true
 
   # To add assets to your package, add an assets section, like this:
   # assets:

cw_bitcoin_cash/pubspec.yaml

@@ -49,6 +49,7 @@ dependency_overrides:
 
 # The following section is specific to Flutter packages.
 flutter:
+    uses-material-design: true
 
 # To add assets to your package, add an assets section, like this:
 # assets:

cw_core/pubspec.yaml

@@ -47,6 +47,7 @@ dependency_overrides:
 
 # The following section is specific to Flutter.
 flutter:
+    uses-material-design: true
 
   # To add assets to your package, add an assets section, like this:
   # assets:

integration_test/components/common_test_cases.dart

@@ -10,10 +10,16 @@ class CommonTestCases {
     hasType<T>();
   }
 
-  Future<void> tapItemByKey(String key, {bool shouldPumpAndSettle = true}) async {
+  Future<void> tapItemByKey(
+    String key, {
+    bool shouldPumpAndSettle = true,
+    int pumpDuration = 100,
+  }) async {
     final widget = find.byKey(ValueKey(key));
     await tester.tap(widget);
-    shouldPumpAndSettle ? await tester.pumpAndSettle() : await tester.pump();
+    shouldPumpAndSettle
+        ? await tester.pumpAndSettle(Duration(milliseconds: pumpDuration))
+        : await tester.pump();
   }
 
   Future<void> tapItemByFinder(Finder finder, {bool shouldPumpAndSettle = true}) async {
@@ -31,6 +37,11 @@ class CommonTestCases {
     expect(typeWidget, findsOneWidget);
   }
 
+  bool isKeyPresent(String key) {
+    final typeWidget = find.byKey(ValueKey(key));
+    return typeWidget.tryEvaluate();
+  }
+
   void hasValueKey(String key) {
     final typeWidget = find.byKey(ValueKey(key));
     expect(typeWidget, findsOneWidget);
@@ -53,33 +64,86 @@ class CommonTestCases {
     await tester.pumpAndSettle();
   }
 
-  Future<void> scrollUntilVisible(String childKey, String parentScrollableKey,
-      {double delta = 300}) async {
-    final scrollableWidget = find.descendant(
-      of: find.byKey(Key(parentScrollableKey)),
+  Future<void> dragUntilVisible(String childKey, String parentKey) async {
+    await tester.pumpAndSettle();
+
+    final itemFinder = find.byKey(ValueKey(childKey));
+    final listFinder = find.byKey(ValueKey(parentKey));
+
+    // Check if the widget is already in the widget tree
+    if (tester.any(itemFinder)) {
+      // Widget is already built and in the tree
+      tester.printToConsole('Child is already present');
+      return;
+    }
+
+    // We can adjust this as needed
+    final maxScrolls = 200;
+
+    int scrolls = 0;
+    bool found = false;
+
+    // We start by scrolling down
+    bool scrollDown = true;
+
+    // Flag to check if we've already reversed direction
+    bool reversedDirection = false;
+
+    // Find the Scrollable associated with the Parent Ad
+    final scrollableFinder = find.descendant(
+      of: listFinder,
       matching: find.byType(Scrollable),
     );
 
-    final isAlreadyVisibile = isWidgetVisible(find.byKey(ValueKey(childKey)));
-
-    if (isAlreadyVisibile) return;
-
-    await tester.scrollUntilVisible(
-      find.byKey(ValueKey(childKey)),
-      delta,
-      scrollable: scrollableWidget,
+    // Ensure that the Scrollable is found
+    expect(
+      scrollableFinder,
+      findsOneWidget,
+      reason: 'Scrollable descendant of the Parent Widget not found.',
     );
-  }
 
-  bool isWidgetVisible(Finder finder) {
-    try {
-      final Element element = finder.evaluate().single;
-      final RenderBox renderBox = element.renderObject as RenderBox;
-      return renderBox.paintBounds
-          .shift(renderBox.localToGlobal(Offset.zero))
-          .overlaps(tester.binding.renderViews.first.paintBounds);
-    } catch (e) {
-      return false;
+    // Get the initial scroll position
+    final scrollableState = tester.state<ScrollableState>(scrollableFinder);
+    double previousScrollPosition = scrollableState.position.pixels;
+
+    while (!found && scrolls < maxScrolls) {
+      tester.printToConsole('Scrolling ${scrollDown ? 'down' : 'up'}, attempt $scrolls');
+
+      // Perform the drag in the current direction
+      await tester.drag(
+        scrollableFinder,
+        scrollDown ? const Offset(0, -100) : const Offset(0, 100),
+      );
+      await tester.pumpAndSettle();
+      scrolls++;
+
+      // Update the scroll position after the drag
+      final currentScrollPosition = scrollableState.position.pixels;
+
+      if (currentScrollPosition == previousScrollPosition) {
+        // Cannot scroll further in this direction
+        if (reversedDirection) {
+          // We've already tried both directions
+          tester.printToConsole('Cannot scroll further in both directions. Widget not found.');
+          break;
+        } else {
+          // Reverse the scroll direction
+          scrollDown = !scrollDown;
+          reversedDirection = true;
+          tester.printToConsole('Reached the end, reversing direction');
+        }
+      } else {
+        // Continue scrolling in the current direction
+        previousScrollPosition = currentScrollPosition;
+      }
+
+      // Check if the widget is now in the widget tree
+      found = tester.any(itemFinder);
+    }
+
+    if (!found) {
+      tester.printToConsole('Widget not found after scrolling in both directions.');
+      return;
     }
   }
 
@@ -91,6 +155,15 @@ class CommonTestCases {
     await tester.pumpAndSettle();
   }
 
+  void findWidgetViaDescendant({
+    required FinderBase<Element> of,
+    required FinderBase<Element> matching,
+  }) {
+    final textWidget = find.descendant(of: of, matching: matching);
+
+    expect(textWidget, findsOneWidget);
+  }
+
   Future<void> defaultSleepTime({int seconds = 2}) async =>
       await Future.delayed(Duration(seconds: seconds));
 }