Remove CoinJoin mixing; begin Kotlin SDK migration (Phases 1, 2, 0 prep + Phase 3 start)

common/build.gradle

@@ -9,7 +9,7 @@ android {
 
     defaultConfig {
         compileSdk 35
-        minSdkVersion 24
+        minSdkVersion 29
         targetSdkVersion 35
         vectorDrawables.useSupportLibrary = true
 
@@ -55,6 +55,9 @@ dependencies {
     implementation 'androidx.appcompat:appcompat:1.2.0'
     implementation "org.dashj:dashj-core:$dashjVersion"
     implementation 'com.google.protobuf:protobuf-javalite:3.17.3'
+    // Needed at compile time by the BIP70 code copied from dashj (payments.bip70.X509Utils);
+    // dashj only exposes bouncycastle as a runtime dependency. Version matches dashj 22.0.3.
+    implementation 'org.bouncycastle:bcprov-jdk15to18:1.74'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion"
 

common/src/main/java/org/dash/wallet/common/WalletDataProvider.kt

@@ -47,8 +47,23 @@ interface WalletDataProvider {
     fun freshReceiveAddress(): Address
     fun currentReceiveAddress(): Address
 
+    // Neutral (dashj-free) accessors for feature/integration modules.
+    // Default implementations delegate to the dashj-typed methods above.
+    val networkId: String
+        get() = networkParameters.id
+    fun freshReceiveAddressString(): String = freshReceiveAddress().toBase58()
+    fun currentReceiveAddressString(): String = currentReceiveAddress().toBase58()
+
     fun getWalletBalance(): Coin
-    fun getMixedBalance(): Coin
+
+    /**
+     * Number of spendable unspent outputs coin selection can draw on —
+     * `calculateAllSpendCandidates(false, false)`, the exact output set
+     * `getBalance(ESTIMATED)` sums (all keychains) — or 0 while no wallet
+     * is loaded.
+     */
+    @Suppress("DEPRECATION")
+    fun spendableUtxoCount(): Int = wallet?.calculateAllSpendCandidates(false, false)?.size ?: 0
 
     fun observeWalletChanged(): Flow<Unit>
 
@@ -59,8 +74,6 @@ interface WalletDataProvider {
         coinSelector: CoinSelector? = null
     ): Flow<Coin>
 
-    fun observeSpendableBalance(): Flow<Coin>
-
     fun canAffordIdentityCreation(): Boolean
 
     // Treat @withConfidence with care - it may produce a lot of events and affect performance.
@@ -84,7 +97,6 @@ interface WalletDataProvider {
     fun checkSendingConditions(address: Address?, amount: Coin)
 
     fun observeMostRecentTransaction(): Flow<Transaction>
-    fun observeMixedBalance(): Flow<Coin>
     fun observeTotalBalance(): Flow<Coin>
     fun lockOutput(outPoint: TransactionOutPoint): Boolean
 }

common/src/main/java/org/dash/wallet/common/WalletDataProviderExt.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2026 Dash Core Group.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.dash.wallet.common
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import org.bitcoinj.core.Sha256Hash
+import org.bitcoinj.wallet.Wallet
+import org.dash.wallet.common.money.Dash
+import org.dash.wallet.common.money.toCoin
+import org.dash.wallet.common.money.toDash
+import org.dash.wallet.common.services.LeftoverBalanceException
+import org.dash.wallet.common.transactions.filters.LockedTransaction
+
+// ---------------------------------------------------------------------------------------------
+// Neutral (dashj-free) adapters over WalletDataProvider for feature/integration modules.
+// They delegate to the dashj-typed interface methods, so behavior is identical.
+// ---------------------------------------------------------------------------------------------
+
+/** [WalletDataProvider.observeTotalBalance] as neutral [Dash] amounts. */
+fun WalletDataProvider.observeTotalDashBalance(): Flow<Dash> = observeTotalBalance().map { it.toDash() }
+
+/** [WalletDataProvider.observeBalance] (with its default estimated balance type) as neutral [Dash] amounts. */
+fun WalletDataProvider.observeDashBalance(): Flow<Dash> = observeBalance().map { it.toDash() }
+
+/** [WalletDataProvider.getWalletBalance] as a neutral [Dash] amount. */
+fun WalletDataProvider.getDashBalance(): Dash = getWalletBalance().toDash()
+
+/** Estimated wallet balance (mirrors `wallet.getBalance(BalanceType.ESTIMATED)`), or null when no wallet is loaded. */
+@Suppress("DEPRECATION")
+fun WalletDataProvider.getEstimatedDashBalance(): Dash? =
+    wallet?.getBalance(Wallet.BalanceType.ESTIMATED)?.toDash()
+
+/**
+ * Emits the hex tx id once the wallet transaction with hex id [txId] is IS-locked or confirmed
+ * (mirrors [WalletDataProvider.observeTransactions] with a [LockedTransaction] filter).
+ */
+fun WalletDataProvider.observeTransactionLocked(txId: String): Flow<String> =
+    observeTransactions(true, LockedTransaction(Sha256Hash.wrap(txId))).map { it.txId.toString() }
+
+/**
+ * Whether the wallet transaction with hex id [txId] is pending (mirrors `Transaction.isPending`);
+ * false if the wallet doesn't know the transaction.
+ */
+fun WalletDataProvider.isTransactionPending(txId: String): Boolean =
+    getTransaction(Sha256Hash.wrap(txId))?.isPending ?: false
+
+/**
+ * Net wallet value of the transaction with hex id [txId] (mirrors
+ * `Transaction.getValue(transactionBag)`), or null if the wallet doesn't know the transaction.
+ */
+fun WalletDataProvider.getTransactionValue(txId: String): Dash? =
+    getTransaction(Sha256Hash.wrap(txId))?.getValue(transactionBag)?.toDash()
+
+/** Serialized hex of the wallet transaction with hex id [txId], or null if unknown. Useful for logging. */
+fun WalletDataProvider.getTransactionHex(txId: String): String? =
+    getTransaction(Sha256Hash.wrap(txId))?.toStringHex()
+
+/**
+ * True when sending [amount] would trip the leftover-balance check
+ * (i.e. [WalletDataProvider.checkSendingConditions] would throw [LeftoverBalanceException]).
+ */
+fun WalletDataProvider.needsLeftoverBalanceWarning(amount: Dash): Boolean {
+    return try {
+        checkSendingConditions(null, amount.toCoin())
+        false
+    } catch (_: LeftoverBalanceException) {
+        true
+    }
+}

common/src/main/java/org/dash/wallet/common/data/BaseConfig.kt

@@ -33,12 +33,15 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.CancellationException
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import org.dash.wallet.common.WalletDataProvider
 import org.dash.wallet.common.util.security.EncryptionProvider
+import org.slf4j.LoggerFactory
 import java.io.IOException
+import java.util.WeakHashMap
 
 abstract class BaseConfig(
     private val context: Context,
@@ -47,9 +50,54 @@ abstract class BaseConfig(
     private val encryptionProvider: EncryptionProvider? = null,
     migrations: List<DataMigration<Preferences>> = listOf()
 ) {
+    companion object {
+        private val log = LoggerFactory.getLogger(BaseConfig::class.java)
+
+        // Registry of live BaseConfig instances, weakly referenced so GC'able
+        // configs don't leak. Every instance registers itself on construction.
+        // A wallet wipe must clear each LIVE config through its DataStore API
+        // (memory + disk reset atomically) instead of deleting the backing file
+        // out-of-band: an out-of-band delete leaves the live DataStore's
+        // in-memory cache populated while disk is empty, so later reads return
+        // stale values and later writes recreate the file with a random subset
+        // of keys (observed live: debug SDK flags never reseeding after a
+        // Reset Wallet because the stale cache made them look already-set).
+        private val registryLock = Any()
+        private val liveInstances = WeakHashMap<BaseConfig, Unit>()
+
+        /**
+         * Clears every live [BaseConfig] instance through its DataStore API and
+         * returns the DataStore file names (e.g. "dashpay.preferences_pb") that
+         * were cleared. An instance whose clear fails is logged and excluded
+         * from the returned set so callers can fall back to raw file deletion
+         * for it.
+         */
+        suspend fun clearAllLiveInstances(): Set<String> {
+            val snapshot = synchronized(registryLock) { liveInstances.keys.toList() }
+            val cleared = mutableSetOf<String>()
+
+            for (instance in snapshot) {
+                try {
+                    instance.clearAll()
+                    cleared.add(instance.preferencesFileName)
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Exception) {
+                    log.warn("failed to clear live config '{}' via API", instance.preferencesFileName, e)
+                }
+            }
+
+            return cleared
+        }
+    }
+
     private val securityKeyAlias = "${name}_security_key"
     private val json = Json { encodeDefaults = true }
 
+    /** File name used by the underlying preferences DataStore for this config. */
+    val preferencesFileName: String
+        get() = "$name.preferences_pb"
+
     protected val Context.dataStore by preferencesDataStore(
         name = name,
         produceMigrations = { migrations }
@@ -65,6 +113,7 @@ abstract class BaseConfig(
         }
 
     init {
+        synchronized(registryLock) { liveInstances[this] = Unit }
         walletDataProvider.attachOnWalletWipedListener {
             clearAll()
         }
@@ -95,7 +144,7 @@ abstract class BaseConfig(
         context.dataStore.secureEdit(value) { preferences, encryptedValue -> preferences[key] = encryptedValue }
     }
 
-    suspend fun clearAll() {
+    open suspend fun clearAll() {
         context.dataStore.edit { it.clear() }
     }
 

common/src/main/java/org/dash/wallet/common/data/PaymentIntent.java

@@ -33,8 +33,8 @@
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.core.Transaction;
-import org.bitcoinj.protocols.payments.PaymentProtocol;
-import org.bitcoinj.protocols.payments.PaymentProtocolException;
+import org.dash.wallet.common.payments.bip70.PaymentProtocol;
+import org.dash.wallet.common.payments.bip70.PaymentProtocolException;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.ScriptBuilder;
 import org.bitcoinj.script.ScriptException;

common/src/main/java/org/dash/wallet/common/data/SyncStage.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2026 Dash Core Group.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.dash.wallet.common.data
+
+/**
+ * Blockchain sync stage, independent of the underlying wallet library.
+ * The wallet module maps its sync engine's stages onto these values.
+ */
+enum class SyncStage {
+    OFFLINE,
+    HEADERS,
+    MNLIST,
+    PREBLOCKS,
+    BLOCKS,
+    COMPLETE
+}

common/src/main/java/org/dash/wallet/common/data/WalletUIConfig.kt

@@ -65,7 +65,6 @@ open class WalletUIConfig @Inject constructor(
         val SELECTED_CURRENCY = stringPreferencesKey("exchange_currency")
         val EXCHANGE_CURRENCY_DETECTED = booleanPreferencesKey("exchange_currency_detected")
         val LAST_TOTAL_BALANCE = longPreferencesKey("last_total_balance")
-        val LAST_MIXED_BALANCE = longPreferencesKey("last_mixed_balance")
         val CUSTOMIZED_SHORTCUTS = stringPreferencesKey("customized_shortcuts")
         val IS_SHORTCUT_INFO_HIDDEN = booleanPreferencesKey("is_shortcut_info_hidden")
     }

common/src/main/java/org/dash/wallet/common/data/entity/GiftCard.kt

@@ -35,4 +35,59 @@ data class GiftCard(
     var note: String? = null, // holds order number
     var index: Int = 0,
     var redeemUrlChallenge: String? = null
-)
+) {
+    companion object {
+        /**
+         * Neutral (dashj-free) factory: builds a GiftCard from a hex transaction id
+         * ([Sha256Hash.toString] format), for modules that must not depend on dashj.
+         */
+        fun fromHex(
+            txId: String,
+            merchantName: String = "",
+            price: Double = 0.0,
+            number: String? = null,
+            pin: String? = null,
+            barcodeValue: String? = null,
+            barcodeFormat: BarcodeFormat? = null,
+            merchantUrl: String? = null,
+            note: String? = null,
+            index: Int = 0,
+            redeemUrlChallenge: String? = null
+        ) = GiftCard(
+            Sha256Hash.wrap(txId), merchantName, price, number, pin, barcodeValue,
+            barcodeFormat, merchantUrl, note, index, redeemUrlChallenge
+        )
+    }
+
+    /** The transaction id as a hex string ([Sha256Hash.toString]); dashj-free accessor. */
+    val txIdHex: String get() = txId.toString()
+
+    /**
+     * Neutral (dashj-free) variant of [copy]: duplicates the card (txId always preserved)
+     * with the given field overrides, for modules that must not depend on dashj.
+     */
+    fun copyCard(
+        merchantName: String = this.merchantName,
+        price: Double = this.price,
+        number: String? = this.number,
+        pin: String? = this.pin,
+        barcodeValue: String? = this.barcodeValue,
+        barcodeFormat: BarcodeFormat? = this.barcodeFormat,
+        merchantUrl: String? = this.merchantUrl,
+        note: String? = this.note,
+        index: Int = this.index,
+        redeemUrlChallenge: String? = this.redeemUrlChallenge
+    ) = copy(
+        txId = txId,
+        merchantName = merchantName,
+        price = price,
+        number = number,
+        pin = pin,
+        barcodeValue = barcodeValue,
+        barcodeFormat = barcodeFormat,
+        merchantUrl = merchantUrl,
+        note = note,
+        index = index,
+        redeemUrlChallenge = redeemUrlChallenge
+    )
+}

common/src/main/java/org/dash/wallet/common/data/entity/TransactionMetadata.kt

@@ -46,6 +46,9 @@ data class TransactionMetadata(
     @Ignore
     val defaultTaxCategory = TaxCategory.getDefault(value.isPositive, isTransfer)
 
+    /** [customIconId] as a hex string ([Sha256Hash.toString]); dashj-free accessor. */
+    val customIconIdHex: String? get() = customIconId?.toString()
+
     fun isNotEmpty(): Boolean {
         return timestamp != 0L || taxCategory != null || memo.isNotEmpty() || currencyCode != null ||
             rate != null || service != null || customIconId != null