Fix: topups

build.gradle

@@ -4,7 +4,7 @@ buildscript {
         coroutinesVersion = '1.6.4'
         ok_http_version = '4.9.1'
         dashjVersion = '21.1.12-SNAPSHOT'
-        dppVersion = "2.0.0"
+        dppVersion = "2.0.1-SNAPSHOT"
         hiltVersion = '2.53'
         hiltCompilerVersion = '1.2.0'
         hiltWorkVersion = '1.2.0'

wallet/src/de/schildbach/wallet/service/platform/PlatformSyncService.kt

@@ -1397,9 +1397,13 @@ class PlatformSynchronizationService @Inject constructor(
         }
     }
 
+    private var hasCheckedTopups = false // only run once
     private suspend fun checkTopUps() {
-        platformRepo.getWalletEncryptionKey()?.let {
-            topUpRepository.checkTopUps(it)
+        if (!hasCheckedTopups) {
+            platformRepo.getWalletEncryptionKey()?.let {
+                topUpRepository.checkTopUps(it)
+                hasCheckedTopups = true
+            }
         }
     }
 }

wallet/src/de/schildbach/wallet/service/platform/TopUpRepository.kt

@@ -46,7 +46,10 @@ import kotlin.coroutines.resumeWithException
 import kotlin.coroutines.suspendCoroutine
 import de.schildbach.wallet.ui.dashpay.CreateIdentityService
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.TimeoutCancellationException
 import org.bitcoinj.wallet.authentication.AuthenticationGroupExtension
+import java.util.concurrent.TimeUnit
 
 /**
  * contains topup related functions that are used by [CreateIdentityService] to create
@@ -254,13 +257,59 @@ class TopUpRepositoryImpl @Inject constructor(
         ) ?: addTopUp(topUpTx.txId)
         Context.propagate(walletDataProvider.wallet!!.context)
         val confidence = topUpTx.getConfidence(walletDataProvider.wallet!!.context)
+        log.info("topup tx confidence: {}", confidence)
         val wasTxSent = confidence.isChainLocked ||
                 confidence.isTransactionLocked ||
+                confidence.confidenceType == TransactionConfidence.ConfidenceType.BUILDING ||
                 confidence.numBroadcastPeers() > 0
+
         if (!wasTxSent) {
             sendTransaction(topUpTx)
+        } else {
+            // wait for IX Lock or mining if the TX has been sent
+            // the transaction was probably sent previously
+            if (confidence.numBroadcastPeers() > 0 && confidence.confidenceType == TransactionConfidence.ConfidenceType.PENDING) {
+                try {
+                    withTimeout(TimeUnit.SECONDS.toMillis(30)) {
+                        suspendCoroutine { continuation ->
+                            val listener = object : TransactionConfidence.Listener {
+                                override fun onConfidenceChanged(confidence: TransactionConfidence?, reason: TransactionConfidence.Listener.ChangeReason?) {
+                                    when (reason) {
+                                        TransactionConfidence.Listener.ChangeReason.IX_TYPE -> {
+                                            if (confidence!!.isTransactionLocked || confidence.ixType == TransactionConfidence.IXType.IX_REQUEST) {
+                                                log.info("topup: observe ISLock")
+                                                confidence.removeEventListener(this)
+                                                continuation.resumeWith(Result.success(Unit))
+                                            }
+                                        }
+                                        TransactionConfidence.Listener.ChangeReason.DEPTH,
+                                        TransactionConfidence.Listener.ChangeReason.CHAIN_LOCKED -> {
+                                            if (confidence!!.confidenceType == TransactionConfidence.ConfidenceType.BUILDING || confidence.isChainLocked) {
+                                                log.info("topup: observe block or chainlock")
+                                                confidence.removeEventListener(this)
+                                                continuation.resumeWith(Result.success(Unit))
+                                            }
+                                        }
+                                        else -> { /* ignore */ }
+                                    }
+                                }
+                            }
+                            confidence.addEventListener(listener)
+                        }
+                    }
+                } catch (e: TimeoutCancellationException) {
+                    // Timeout reached, continue with execution
+                    log.info("topup, timeout waiting for islock, continue...")
+                }
+            }
+
         }
-        log.info("topup tx sent: {}", topUpTx.txId)
+        val status = when (confidence.confidenceType) {
+            TransactionConfidence.ConfidenceType.BUILDING -> "mined in block ${confidence.appearedAtChainHeight}"
+            TransactionConfidence.ConfidenceType.PENDING -> "broadcast tx to ${confidence.numBroadcastPeers()} peers"
+            else -> confidence.toString()
+        }
+        log.info("topup tx sent: {}; tx = {}", status, topUpTx.txId)
         try {
             platformRepo.blockchainIdentity.topUp(
                 topUpTx,
@@ -275,6 +324,7 @@ class TopUpRepositoryImpl @Inject constructor(
             if (e.message?.let { regex.matches(it) || it.contains("Object already exists: state transition already in chain")} == true) {
                 // the asset lock was already used
                 topUpsDao.insert(topUp.copy(creditedAt = System.currentTimeMillis()))
+                log.info("topup success, already submitted: {}", topUpTx.txId)
             } else {
                 throw e
             }
@@ -305,10 +355,14 @@ class TopUpRepositoryImpl @Inject constructor(
                     if (topUp == null) {
                         topUpsDao.insert(TopUp(assetLockTx.txId, identity))
                     }
-                    topUpIdentity(assetLockTx, platformRepo.getWalletEncryptionKey()!!)
+                    try {
+                        topUpIdentity(assetLockTx, platformRepo.getWalletEncryptionKey()!!)
 //                    TopupIdentityOperation(walletApplication)
 //                        .create(identity, assetLockTx.txId)
 //                        .enqueue()
+                    } catch (e: Exception) {
+                        // swallow
+                    }
                 }
             }
             checkedPreviousTopUps = true

wallet/src/de/schildbach/wallet/ui/BlockListFragment.java

@@ -171,7 +171,11 @@ public void onPause() {
 	@Override
     public void onDestroy() {
 		if (serviceIsBound) {
-			activity.unbindService(serviceConnection);
+			try {
+				activity.unbindService(serviceConnection);
+			} catch (IllegalArgumentException e) {
+				log.warn("Service not registered when unbinding", e);
+			}
 			serviceIsBound = false;
 		}
 

wallet/src/de/schildbach/wallet/ui/transactions/TransactionResultViewBinder.kt

@@ -161,7 +161,7 @@ class TransactionResultViewBinder(
         } else {
             setInputs(inputAddresses, inflater)
             setOutputs(outputAddresses, inflater)
-            //setReturns(outputAssetLocks, inflater, false)
+            setReturns(outputAssetLocks, inflater, false, true)
         }
 
         // For displaying purposes only