fix: change Wallet.lock to ReentrantReadWriteLock

core/src/main/java/org/bitcoinj/coinjoin/utils/CoinJoinManager.java

@@ -71,6 +71,7 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
@@ -507,10 +508,14 @@ public void processTransaction(Transaction tx) {
     public final PreMessageReceivedEventListener preMessageReceivedEventListener = (peer, m) -> {
         if (m instanceof CoinJoinQueue) {
             // Offload DSQueue message processing to thread pool to avoid blocking network I/O thread
-            messageProcessingExecutor.execute(() -> {
-                processMessage(peer, m);
-            });
-            // Return null as dsq meessages are only processed above
+            try {
+                messageProcessingExecutor.execute(() -> {
+                    processMessage(peer, m);
+                });
+            } catch (RejectedExecutionException e) {
+                // Executor was shutdown - ignore, we're shutting down
+            }
+            // Return null as dsq messages are only processed above
             return null;
         } else if (isCoinJoinMessage(m)) {
             // Process other CoinJoin messages synchronously

core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java

@@ -1134,8 +1134,8 @@ public void handleChainLock(StoredBlock chainLockedBlock) {
                         handleNewBestChain(prevBlock, newTip, newTip.getHeader(), shouldVerifyTransactions());
                     }
                 } catch (BlockStoreException | PrunedException x) {
-                    log.info("handle chain lock exception:", x);
-                    // swallow
+                    log.debug("handle chain lock exception:", x);
+                    // swallow - expected during shutdown
                 }
             }
         } finally {

core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java

@@ -202,14 +202,19 @@ public TransactionConfidence get(Sha256Hash hash) {
     }
 
     public ArrayList<TransactionConfidence> get(StoredBlock block) {
-        ArrayList<TransactionConfidence> results = Lists.newArrayList();
-        for (Map.Entry<Sha256Hash, WeakConfidenceReference> entry: table.entrySet()) {
-            TransactionConfidence confidence = entry.getValue().get();
-            if (confidence != null && confidence.getConfidenceType() == TransactionConfidence.ConfidenceType.BUILDING &&
-                    confidence.getAppearedAtChainHeight() <= block.getHeight()) {
-                results.add(confidence);
+        lock.lock();
+        try {
+            ArrayList<TransactionConfidence> results = Lists.newArrayList();
+            for (Map.Entry<Sha256Hash, WeakConfidenceReference> entry: table.entrySet()) {
+                TransactionConfidence confidence = entry.getValue().get();
+                if (confidence != null && confidence.getConfidenceType() == TransactionConfidence.ConfidenceType.BUILDING &&
+                        confidence.getAppearedAtChainHeight() <= block.getHeight()) {
+                    results.add(confidence);
+                }
             }
+            return results;
+        } finally {
+            lock.unlock();
         }
-        return results;
     }
 }

core/src/main/java/org/bitcoinj/utils/Threading.java

@@ -31,6 +31,7 @@
 import java.lang.management.ThreadMXBean;
 import java.util.concurrent.*;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 /**
  * Various threading related utilities. Provides a wrapper around explicit lock creation that lets you control whether
@@ -192,6 +193,13 @@ public static CycleDetectingLockFactory.Policy getPolicy() {
         return policy;
     }
 
+    public static ReentrantReadWriteLock readWriteLock(String name) {
+        if (Utils.isAndroidRuntime() && useDefaultAndroidPolicy)
+            return new ReentrantReadWriteLock(true);
+        else
+            return factory.newReentrantReadWriteLock(name, true);
+    }
+
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
     // Generic worker pool.

core/src/main/java/org/bitcoinj/wallet/AbstractKeyChainGroupExtension.java

@@ -544,4 +544,9 @@ public void setWallet(Wallet wallet) {
     public int getCombinedKeyLookaheadEpochs() {
         return hasKeyChains() ? getKeyChainGroup().getCombinedKeyLookaheadEpochs() : 0;
     }
+
+    @Override
+    public int getTotalIssuedKeys() {
+        return hasKeyChains() ? getKeyChainGroup().getTotalIssuedKeys() : 0;
+    }
 }

core/src/main/java/org/bitcoinj/wallet/AnyKeyChainGroup.java

@@ -651,6 +651,17 @@ public int numKeys() {
         return result;
     }
 
+    /**
+     * Returns number of keys used on external and internal paths.
+     */
+    public int getTotalIssuedKeys() {
+        int result = basic.numKeys();
+        if (chains != null)
+            for (AnyDeterministicKeyChain chain : chains)
+                result += chain.numLeafKeysIssued();
+        return result;
+    }
+
     /**
      * Removes a key that was imported into the basic key chain. You cannot remove deterministic keys.
      * @throws IllegalArgumentException if the key is deterministic.

core/src/main/java/org/bitcoinj/wallet/CoinJoinExtension.java

@@ -227,6 +227,9 @@ public void deserializeWalletExtension(Wallet containingWallet, byte[] data) thr
         if (containingWallet instanceof WalletEx && coinJoinProto.hasOutpointRoundsCache()) {
             WalletEx walletEx = (WalletEx) containingWallet;
             Protos.OutpointRoundsCache cacheProto = coinJoinProto.getOutpointRoundsCache();
+            // Pre-size HashMap to avoid resizing during deserialization
+            int entryCount = cacheProto.getEntriesCount();
+            walletEx.mapOutpointRoundsCache = new HashMap<>(entryCount * 4 / 3 + 1);
             for (Protos.OutpointRoundsEntry entryProto : cacheProto.getEntriesList()) {
                 Sha256Hash txHash = Sha256Hash.wrap(entryProto.getTransactionHash().toByteArray());
                 long outputIndex = entryProto.getOutputIndex();

core/src/main/java/org/bitcoinj/wallet/KeyChainGroup.java

@@ -627,6 +627,17 @@ public int numKeys() {
         return result;
     }
 
+    /**
+     * Returns number of keys used on external and internal paths.
+     */
+    public int getTotalIssuedKeys() {
+        int result = basic.numKeys();
+        if (chains != null)
+            for (DeterministicKeyChain chain : chains)
+                result += chain.numLeafKeysIssued();
+        return result;
+    }
+
     /**
      * Removes a key that was imported into the basic key chain. You cannot remove deterministic keys.
      * @throws java.lang.IllegalArgumentException if the key is deterministic.

core/src/main/java/org/bitcoinj/wallet/KeyChainGroupExtension.java

@@ -96,4 +96,5 @@ default String toString(boolean includeLookahead, boolean includePrivateKeys, @N
     boolean isTransactionRevelant(Transaction tx);
 
     int getCombinedKeyLookaheadEpochs();
+    int getTotalIssuedKeys();
 }