Silly hack(?) to temporarily show mweb spends.

Note: Unless wallet is open when the transaction confirms the tx details view will show the wrong transaction height.

Author: julian-CStack

lib/wallets/wallet/impl/litecoin_wallet.dart

@@ -361,6 +361,10 @@ class LitecoinWallet<T extends ElectrumXCurrencyInterface>
     }
 
     await mainDB.updateOrPutTransactionV2s(txns);
+
+    if (info.isMwebEnabled) {
+      await checkMwebSpends();
+    }
   }
 
   @override

lib/wallets/wallet/wallet_mixin_interfaces/electrumx_interface.dart

@@ -907,8 +907,23 @@ mixin ElectrumXInterface<T extends ElectrumXCurrencyInterface>
       // dirty shortcut for peercoin's weirdness
       vSize: this is PeercoinWallet ? clTx.size : clTx.vSize(),
       tempTx:
-          txData.type.isMweb()
+          txData.type == TxType.mwebPegIn
               ? null
+              : txData.type.isMweb()
+              ? TransactionV2(
+                walletId: walletId,
+                blockHash: null,
+                hash: clTx.hashHex,
+                txid: clTx.txid,
+                height: null,
+                timestamp: DateTime.timestamp().millisecondsSinceEpoch ~/ 1000,
+                inputs: List.unmodifiable(tempInputs),
+                outputs: List.unmodifiable(tempOutputs),
+                version: clTx.version,
+                type: TransactionType.outgoing,
+                subType: TransactionSubType.mweb,
+                otherData: null,
+              )
               : TransactionV2(
                 walletId: walletId,
                 blockHash: null,

lib/wallets/wallet/wallet_mixin_interfaces/mweb_interface.dart

@@ -358,6 +358,56 @@ mixin MwebInterface<T extends ElectrumXCurrencyInterface>
     );
   }
 
+  Future<void> checkMwebSpends() async {
+    final pending =
+        await mainDB.isar.transactionV2s
+            .where()
+            .walletIdEqualTo(walletId)
+            .filter()
+            .heightIsNull()
+            .and()
+            .blockHashIsNull()
+            .and()
+            .subTypeEqualTo(TransactionSubType.mweb)
+            .and()
+            .typeEqualTo(TransactionType.outgoing)
+            .findAll();
+
+    Logging.instance.f(pending);
+
+    final client = await _client;
+    for (final tx in pending) {
+      for (final input in tx.inputs) {
+        if (input.addresses.length == 1) {
+          final address = await mainDB.getAddress(
+            walletId,
+            input.addresses.first,
+          );
+          if (address?.type == AddressType.mweb) {
+            final response = await client.spent(
+              SpentRequest(outputId: [input.outpoint!.txid]),
+            );
+            if (response.outputId.contains(input.outpoint!.txid)) {
+              // dummy to show tx as confirmed. Need a better way to handle this as its kind of stupid, resulting in terrible UX
+              final dummyHeight = await chainHeight;
+
+              TransactionV2? transaction =
+                  await mainDB.isar.transactionV2s
+                      .where()
+                      .txidWalletIdEqualTo(tx.txid, walletId)
+                      .findFirst();
+
+              if (transaction == null || transaction.height == null) {
+                transaction = (transaction ?? tx).copyWith(height: dummyHeight);
+                await mainDB.updateOrPutTransactionV2s([transaction]);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
   Future<TxData> processMwebTransaction(TxData txData) async {
     final client = await _client;
     final response = await client.create(