From a10eaf92962d5e83c38823870d54eed312fd239f Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Thu, 5 Mar 2026 16:16:48 -0800
Subject: [PATCH 01/22] chore: update idea test configuration file

---
 .run/Tests in 'dashj-master-three.core.test'.run.xml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.run/Tests in 'dashj-master-three.core.test'.run.xml b/.run/Tests in 'dashj-master-three.core.test'.run.xml
index 86f8b6f046..b9960d7723 100644
--- a/.run/Tests in 'dashj-master-three.core.test'.run.xml	
+++ b/.run/Tests in 'dashj-master-three.core.test'.run.xml	
@@ -10,7 +10,7 @@
       </option>
       <option name="taskNames">
         <list>
-          <option value=":core:test" />
+          <option value=":dashj-core:test" />
         </list>
       </option>
       <option name="vmOptions" />
@@ -18,6 +18,7 @@
     <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
     <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
     <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
     <method v="2" />
   </configuration>
 </component>
\ No newline at end of file

From d682ec0d2a0c819e6ce1017ec45d6de9def84b37 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Thu, 5 Mar 2026 16:18:37 -0800
Subject: [PATCH 02/22] fix: support processing islocks on the background
 thread by default

---
 .../java/org/bitcoinj/manager/DashSystem.java |   2 +-
 .../bitcoinj/quorums/InstantSendManager.java  | 135 ++++--------------
 .../quorums/LLMQBackgroundThread.java         |  10 +-
 3 files changed, 35 insertions(+), 112 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/manager/DashSystem.java b/core/src/main/java/org/bitcoinj/manager/DashSystem.java
index 9893399be5..2680ecff8f 100644
--- a/core/src/main/java/org/bitcoinj/manager/DashSystem.java
+++ b/core/src/main/java/org/bitcoinj/manager/DashSystem.java
@@ -142,7 +142,7 @@ public void initDash(boolean liteMode, boolean allowInstantX, @Nullable EnumSet<
         signingManager = new SigningManager(context, recoveredSigsDB, quorumManager, masternodeSync);
 
         instantSendDB = new SPVInstantSendDatabase(context);
-        instantSendManager = new InstantSendManager(context, instantSendDB, signingManager);
+        instantSendManager = new InstantSendManager(context, instantSendDB, signingManager, false);
         chainLockHandler = new ChainLocksHandler(context);
         llmqBackgroundThread = new LLMQBackgroundThread(context, instantSendManager, chainLockHandler, signingManager, masternodeListManager);
         masternodeMetaDataManager = new MasternodeMetaDataManager(context);
diff --git a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
index f0fb1dbda4..a07ee6d4d0 100644
--- a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
+++ b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
@@ -52,13 +52,10 @@ public class InstantSendManager implements RecoveredSignatureListener {
     protected MasternodeSync masternodeSync;
     protected SporkManager sporkManager;
     protected SimplifiedMasternodeListManager masternodeListManager;
-    @Deprecated
-    Thread workThread;
-    @Deprecated
-    private boolean runWithoutThread = true;
+    private final boolean runWithoutThread;
     private ScheduledExecutorService scheduledExecutorService;
-    AbstractBlockChain blockChain;
-    private ArrayList<Wallet> wallets = new ArrayList<>();
+    private AbstractBlockChain blockChain;
+    private final ArrayList<Wallet> wallets = new ArrayList<>();
 
     //Keep track of when the ISLOCK arrived
     HashMap<InstantSendLock, Long> invalidInstantSendLocks;
@@ -66,23 +63,26 @@ public class InstantSendManager implements RecoveredSignatureListener {
     // Incoming and not verified yet
     HashMap<Sha256Hash, Pair<Long, InstantSendLock>> pendingInstantSendLocks;
 
-    public InstantSendManager(Context context, InstantSendDatabase db, SigningManager signingManager) {
+    public InstantSendManager(Context context, InstantSendDatabase db, SigningManager signingManager, boolean runWithoutThread) {
         this.context = context;
         this.db = db;
         this.quorumSigningManager = signingManager;
         pendingInstantSendLocks = new HashMap<>();
         invalidInstantSendLocks = new HashMap<>();
+        this.runWithoutThread = runWithoutThread;
         scheduledExecutorService = createScheduledExecutorService();
     }
 
     public InstantSendManager(Context context, InstantSendDatabase db, AbstractBlockChain blockChain,
                               @Nullable PeerGroup peerGroup, @Nullable ChainLocksHandler chainLocksHandler, SigningManager signingManager,
-                              MasternodeSync masternodeSync, SporkManager sporkManager) {
+                              MasternodeSync masternodeSync, SporkManager sporkManager,
+                              SimplifiedMasternodeListManager masternodeListManager, boolean runWithoutThread) {
         this.context = context;
         this.db = db;
         this.quorumSigningManager = signingManager;
         pendingInstantSendLocks = new HashMap<>();
         invalidInstantSendLocks = new HashMap<>();
+        this.runWithoutThread = runWithoutThread;
         scheduledExecutorService = createScheduledExecutorService();
         setBlockChain(blockChain, peerGroup, chainLocksHandler, masternodeSync, sporkManager, masternodeListManager);
     }
@@ -96,23 +96,6 @@ public String toString() {
         return String.format("InstantSendManager:  pendingInstantSendLocks %d, DB: %s", pendingInstantSendLocks.size(), db);
     }
 
-//    public InstantSendManager(Context context, InstantSendDatabase db, boolean runWithoutThread) {
-//        this(context, db);
-//        this.runWithoutThread = runWithoutThread;
-//    }
-
-//    public void setBlockChain(AbstractBlockChain blockChain, @Nullable PeerGroup peerGroup) {
-//        this.peerGroup = peerGroup;
-//        this.blockChain = blockChain;
-//        this.blockChain.addTransactionReceivedListener(this.transactionReceivedInBlockListener);
-//        this.blockChain.addNewBestBlockListener(this.newBestBlockListener);
-//        if (peerGroup != null) {
-//            peerGroup.addOnTransactionBroadcastListener(this.transactionBroadcastListener);
-//        }
-//        if (scheduledExecutorService == null)
-//            scheduledExecutorService = createScheduledExecutorService();
-//    }
-
     public void setBlockChain(AbstractBlockChain blockChain, @Nullable PeerGroup peerGroup,
                               @Nullable ChainLocksHandler chainLocksHandler, MasternodeSync masternodeSync,
                               SporkManager sporkManager, SimplifiedMasternodeListManager masternodeListManager) {
@@ -234,11 +217,14 @@ public void processInstantSendLock(Peer peer, InstantSendLock isLock) {
 
             pendingInstantSendLocks.put(hash, new Pair<>((long)peer.hashCode(), isLock));
 
-            if(runWithoutThread) {
+            if (runWithoutThread) {
                 try {
                     processPendingInstantSendLocks();
-                } catch (BlockStoreException x) {
-                    throw new VerificationException(x.getMessage());
+                } catch (RuntimeException x) {
+                    if (x.getCause() instanceof BlockStoreException) {
+                        throw new VerificationException(x.getCause().getMessage());
+                    }
+                    throw x;
                 }
             }
         } finally {
@@ -324,64 +310,6 @@ public boolean alreadyHave(InventoryItem inv)
         }
     }
 
-    Runnable workerMainThread = new Runnable() {
-        @Override
-        public void run() {
-            try {
-                while (!workThread.isInterrupted()) {
-                    boolean didWork = processPendingInstantSendLocks();
-
-                    if (!didWork) {
-                        Thread.sleep(100);
-                    }
-                }
-            } catch (InterruptedException x) {
-                //let the thread stop
-            } catch (BlockStoreException x) {
-                throw new RuntimeException(x);
-            }
-        }
-    };
-
-    @Deprecated
-    public void start() {
-        if(!runWithoutThread) {
-            if (workThread != null)
-                throw new IllegalThreadStateException("Thread is already running");
-
-            workThread = new Thread(workerMainThread);
-            workThread.start();
-        }
-        quorumSigningManager.addRecoveredSignatureListener(this);
-    }
-
-    @Deprecated
-    public void stop() {
-
-        quorumSigningManager.removeRecoveredSignatureListener(this);
-        if(runWithoutThread)
-            return;
-
-        if(workThread == null)
-            throw new IllegalThreadStateException("Thread is not running");
-
-        try {
-
-            if (!workThread.isInterrupted()) {
-                workThread.join();
-                workThread = null;
-            } else {
-                throw new IllegalThreadStateException("Thread was not interrupted");
-            }
-        } catch (InterruptedException x) {
-            throw new IllegalThreadStateException("Thread was interrupted while waiting for it to die");
-        }
-    }
-
-    void interuptWorkerThread() {
-        workThread.interrupt();
-    }
-
     public boolean checkCanLock(Transaction tx) {
         return checkCanLock(tx, false);
     }
@@ -389,7 +317,7 @@ public boolean checkCanLock(Transaction tx) {
     public boolean checkCanLock(Transaction tx, boolean printDebug)
     {
         if (tx.getInputs().isEmpty()) {
-            // can't lock TXs without inputs (e.g. quorum commitments)
+            // can't lock TXs without inputs (e.g., quorum commitments)
             return false;
         }
 
@@ -482,7 +410,7 @@ boolean checkCanLock(TransactionOutPoint outpoint, boolean printDebug, Sha256Has
                 TransactionOutput output = outpoint.getConnectedOutput();
                 if(output != null) {
                     Transaction parent = output.getParentTransaction();
-                    TransactionConfidence confidence = parent.getConfidence();
+                    TransactionConfidence confidence = parent != null ? parent.getConfidence() : null;
                     if(confidence != null && confidence.getDepthInBlocks() < nInstantSendConfirmationsRequired) {
                         StoredBlock block = blockStore.get(confidence.getAppearedAtChainHeight());
                         if (chainLocksHandler.hasChainLock(confidence.getAppearedAtChainHeight(), block.getHeader().getHash()))
@@ -503,7 +431,7 @@ boolean checkCanLock(TransactionOutPoint outpoint, boolean printDebug, Sha256Has
         return true;
     }
 
-    boolean processPendingInstantSendLocks() throws BlockStoreException {
+    boolean processPendingInstantSendLocks() {
         if (isInitialized()) {
             StoredBlock blockTip = blockChain.getChainHead();
             if (blockTip != null && context.getParams().isDIP0024Active(blockTip)) {
@@ -516,7 +444,7 @@ boolean processPendingInstantSendLocks() throws BlockStoreException {
         return false;
     }
 
-    boolean processPendingInstantSendLocks(boolean isDeterministic) throws BlockStoreException {
+    boolean processPendingInstantSendLocks(boolean isDeterministic) {
         HashMap<Sha256Hash, Pair<Long, InstantSendLock>> pend = new HashMap<>();
         boolean moreWork = false;
 
@@ -575,13 +503,7 @@ boolean processPendingInstantSendLocks(boolean isDeterministic) throws BlockStor
             log.info("InstantSendManager -- doing verification on old active set");
 
             // filter out valid IS locks from "pend"
-            Iterator<Map.Entry<Sha256Hash, Pair<Long, InstantSendLock>>> iterator = pend.entrySet().iterator();
-            while (iterator.hasNext()) {
-                Map.Entry<Sha256Hash, Pair<Long, InstantSendLock>> entry = iterator.next();
-                if (!badISLocks.contains(entry.getKey())) {
-                    iterator.remove();
-                }
-            }
+            pend.entrySet().removeIf(entry -> !badISLocks.contains(entry.getKey()));
             // Now check against the previous active set and perform banning if this fails
             processPendingInstantSendLocks(llmqType, dkgInterval, pend, true);
         }
@@ -813,7 +735,7 @@ void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
             }
 
             //
-            // If an ISLOCK was originally invalid, but was later validated
+            // If an ISLOCK was originally invalid, but was later validated.
             // remove it here
             //
             if(invalidInstantSendLocks.containsKey(islock))
@@ -844,7 +766,7 @@ public void syncTransaction(Transaction tx, StoredBlock block, int posInBlock) {
         }
 
         if (tx.isCoinBase() || tx.getInputs().isEmpty()) {
-            // coinbase can't and TXs with no inputs be locked
+            // coinbase and TXs with no inputs can't be locked
             return;
         }
 
@@ -947,13 +869,11 @@ Sha256Hash getRequestId(TransactionOutPoint outpoint) {
         }
     }
 
-    void removeMempoolConflictsForLock(Sha256Hash hash, InstantSendLock islock)
-    {
+    void removeMempoolConflictsForLock(Sha256Hash hash, InstantSendLock islock) {
         //TODO:  should full verification mode have this?
     }
 
-    public InstantSendLock getInstantSendLockByHash(Sha256Hash hash)
-    {
+    public InstantSendLock getInstantSendLockByHash(Sha256Hash hash) {
         if (!isInstantSendEnabled()) {
             return null;
         }
@@ -967,8 +887,7 @@ public InstantSendLock getInstantSendLockByHash(Sha256Hash hash)
         }
     }
 
-    public InstantSendLock getInstantSendLockByTxId(Sha256Hash hash)
-    {
+    public InstantSendLock getInstantSendLockByTxId(Sha256Hash hash) {
         if (!isInstantSendEnabled()) {
             return null;
         }
@@ -1000,8 +919,7 @@ public InstantSendLock getInstantSendLockByTxId(Sha256Hash hash)
         }
     }
 
-    boolean isLocked(Sha256Hash txHash)
-    {
+    boolean isLocked(Sha256Hash txHash) {
         if (!isInstantSendEnabled()) {
             return false;
         }
@@ -1023,8 +941,7 @@ public boolean isConflicted(Transaction tx) {
         }
     }
 
-    public Sha256Hash getConflictingTx(Transaction tx)
-    {
+    public Sha256Hash getConflictingTx(Transaction tx) {
         if (!isInstantSendEnabled()) {
             return null;
         }
diff --git a/core/src/main/java/org/bitcoinj/quorums/LLMQBackgroundThread.java b/core/src/main/java/org/bitcoinj/quorums/LLMQBackgroundThread.java
index 67eb2e3b43..0943b4f462 100644
--- a/core/src/main/java/org/bitcoinj/quorums/LLMQBackgroundThread.java
+++ b/core/src/main/java/org/bitcoinj/quorums/LLMQBackgroundThread.java
@@ -34,6 +34,7 @@ public LLMQBackgroundThread(Context context, InstantSendManager instantSendManag
         this.chainLocksHandler = chainLocksHandler;
         this.signingManager = signingManager;
         this.masternodeListManager = masternodeListManager;
+        this.setName("LLMQBackgroundThread");
     }
 
     int debugTimer = 0;
@@ -73,11 +74,16 @@ public void run() {
                 }
 
             }
-        } catch (BlockStoreException x) {
-            log.info("stopping LLMQBackgroundThread via BlockStoreException");
+        } catch (RuntimeException x) {
+            if (x.getCause() instanceof BlockStoreException) {
+                log.info("stopping LLMQBackgroundThread via BlockStoreException");
+            } else {
+                log.error("stopping LLMQBackgroundThread via RuntimeException", x);
+            }
         } catch (InterruptedException x) {
             log.info("stopping LLMQBackgroundThread via InterruptedException");
             //let the thread stop
+            Thread.currentThread().interrupt();
         } finally {
             signingManager.removeRecoveredSignatureListener(instantSendManager);
             signingManager.removeRecoveredSignatureListener(chainLocksHandler);

From 9b5d098e7fabf4faf44ed0aaf8ad2b1cb67206ff Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 13 Mar 2026 17:04:56 -0700
Subject: [PATCH 03/22] fix: add parallelization to Wallet protobuf reading

---
 .../wallet/WalletProtobufSerializer.java      | 427 ++++++++++++++----
 1 file changed, 344 insertions(+), 83 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
index 99d77d1be8..81fc56e94a 100644
--- a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
+++ b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
@@ -56,6 +56,8 @@
 import java.net.UnknownHostException;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
@@ -197,6 +199,16 @@ private static int getComplexityScore(Wallet wallet) {
         return transactionCount + (watchedScriptCount * 2) + keyCount;
     }
 
+    private static int getProtoComplexityScore(Protos.Wallet walletProto) {
+        int score = walletProto.getTransactionCount() + walletProto.getKeyCount()
+                + walletProto.getKeysForFriendsCount() + walletProto.getKeysFromFriendsCount();
+
+        for (int i = 0; i < walletProto.getExtensionCount(); ++i) {
+            score += walletProto.getExtension(i).getData().size() / 200;
+        }
+        return score;
+    }
+
     /**
      * Formats the given wallet (transactions and keys) to the given output stream in protocol buffer format.<p>
      *
@@ -897,114 +909,358 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
         if (!walletProto.getNetworkIdentifier().equals(params.getId()))
             throw new UnreadableWalletException.WrongNetwork();
 
-        // Read the scrypt parameters that specify how encryption and decryption is performed.
-        KeyChainGroup keyChainGroup;
-        if (walletProto.hasEncryptionParameters()) {
-            Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
-            final KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
-            keyChainGroup = KeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeyList(), keyCrypter, keyChainFactory);
-        } else {
-            keyChainGroup = KeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeyList(), keyChainFactory);
-        }
-        Wallet wallet = factory.create(params, keyChainGroup);
+        long methodStart = System.currentTimeMillis();
+        int complexityScore = getProtoComplexityScore(walletProto);
+        boolean isLargeWallet = complexityScore > 10_000;
+
+        if (isLargeWallet) {
+            final long[] keysTime = {0}, friendRecvTime = {0}, friendSendTime = {0}, txTime = {0};
+            final boolean hasEncryption = walletProto.hasEncryptionParameters();
+            final KeyCrypterScrypt keyCrypter = hasEncryption ?
+                    new KeyCrypterScrypt(walletProto.getEncryptionParameters()) : null;
 
-        List<Script> scripts = Lists.newArrayList();
-        for (Protos.Script protoScript : walletProto.getWatchedScriptList()) {
+            ExecutorService executor = Executors.newFixedThreadPool(4,
+                    new ContextPropagatingThreadFactory("wallet-deserializer"));
             try {
-                Script script =
-                        new Script(protoScript.getProgram().toByteArray(),
-                                protoScript.getCreationTimestamp() / 1000);
-                scripts.add(script);
-            } catch (ScriptException e) {
-                throw new UnreadableWalletException("Unparseable script in wallet");
-            }
-        }
+                // Future 1: Parse key chain group (most expensive)
+                CompletableFuture<KeyChainGroup> keysFuture = CompletableFuture.supplyAsync(() -> {
+                    log.info("readWallet: keys thread started ({} keys)", walletProto.getKeyCount());
+                    long start = System.currentTimeMillis();
+                    try {
+                        KeyChainGroup kcg = hasEncryption ?
+                                KeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeyList(), keyCrypter, keyChainFactory) :
+                                KeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeyList(), keyChainFactory);
+                        keysTime[0] = System.currentTimeMillis() - start;
+                        log.info("readWallet: keys thread done in {}ms", keysTime[0]);
+                        return kcg;
+                    } catch (UnreadableWalletException e) {
+                        throw new RuntimeException(e);
+                    }
+                }, executor);
+
+                // Future 2: Parse receiving friend key chains (if present)
+                CompletableFuture<FriendKeyChainGroup> friendRecvFuture = null;
+                if (walletProto.getKeysForFriendsCount() > 0) {
+                    friendRecvFuture = CompletableFuture.supplyAsync(() -> {
+                        log.info("readWallet: friendRecv thread started ({} keys)", walletProto.getKeysForFriendsCount());
+                        long start = System.currentTimeMillis();
+                        try {
+                            FriendKeyChainGroup fkcg = hasEncryption ?
+                                    FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysForFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN) :
+                                    FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysForFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
+                            friendRecvTime[0] = System.currentTimeMillis() - start;
+                            log.info("readWallet: friendRecv thread done in {}ms", friendRecvTime[0]);
+                            return fkcg;
+                        } catch (UnreadableWalletException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }, executor);
+                }
+
+                // Future 3: Parse sending friend key chains (if present)
+                CompletableFuture<FriendKeyChainGroup> friendSendFuture = null;
+                if (walletProto.getKeysFromFriendsCount() > 0) {
+                    friendSendFuture = CompletableFuture.supplyAsync(() -> {
+                        log.info("readWallet: friendSend thread started ({} keys)", walletProto.getKeysFromFriendsCount());
+                        long start = System.currentTimeMillis();
+                        try {
+                            FriendKeyChainGroup fkcg = hasEncryption ?
+                                    FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysFromFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN) :
+                                    FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysFromFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
+                            friendSendTime[0] = System.currentTimeMillis() - start;
+                            log.info("readWallet: friendSend thread done in {}ms", friendSendTime[0]);
+                            return fkcg;
+                        } catch (UnreadableWalletException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }, executor);
+                }
+
+                // Futures 4+: Parse each transaction independently (no txMap writes yet)
+                Map<ByteString, Transaction> parsedTxs = new ConcurrentHashMap<>();
+                List<CompletableFuture<Void>> txFutures = new ArrayList<>();
+                long txFuturesStart = System.currentTimeMillis();
+                if (!forceReset) {
+                    log.info("readWallet: tx threads starting ({} transactions)", walletProto.getTransactionCount());
+                    for (Protos.Transaction txProto : walletProto.getTransactionList()) {
+                        txFutures.add(CompletableFuture.runAsync(() -> {
+                            try {
+                                Transaction tx = parseTransactionFromProto(txProto, params);
+                                if (parsedTxs.putIfAbsent(txProto.getHash(), tx) != null)
+                                    throw new RuntimeException(new UnreadableWalletException(
+                                            "Wallet contained duplicate transaction " + byteStringToHash(txProto.getHash())));
+                            } catch (UnreadableWalletException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }, executor));
+                    }
+                }
+
+                // While parallel tasks run, parse the quick sequential parts
+                List<Script> scripts = new ArrayList<>();
+                for (Protos.Script protoScript : walletProto.getWatchedScriptList()) {
+                    try {
+                        scripts.add(new Script(protoScript.getProgram().toByteArray(),
+                                protoScript.getCreationTimestamp() / 1000));
+                    } catch (ScriptException e) {
+                        throw new UnreadableWalletException("Unparseable script in wallet");
+                    }
+                }
+
+                // Retrieve key chain group and create wallet (blocks on keysFuture)
+                KeyChainGroup keyChainGroup;
+                try {
+                    keyChainGroup = keysFuture.get();
+                } catch (ExecutionException e) {
+                    Throwable cause = e.getCause();
+                    if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                    throw new UnreadableWalletException("Failed to parse key chain group", e);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    throw new UnreadableWalletException("Interrupted while parsing key chain group");
+                }
+                Wallet wallet = factory.create(params, keyChainGroup);
+
+                if (friendRecvFuture != null) {
+                    try {
+                        wallet.setReceivingFromFriendsGroup(friendRecvFuture.get());
+                    } catch (ExecutionException e) {
+                        Throwable cause = e.getCause();
+                        if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                        throw new UnreadableWalletException("Failed to parse receiving friend keys", e);
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        throw new UnreadableWalletException("Interrupted while parsing receiving friend keys");
+                    }
+                }
+
+                if (friendSendFuture != null) {
+                    try {
+                        wallet.setSendingToFriendsGroup(friendSendFuture.get());
+                    } catch (ExecutionException e) {
+                        Throwable cause = e.getCause();
+                        if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                        throw new UnreadableWalletException("Failed to parse sending friend keys", e);
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        throw new UnreadableWalletException("Interrupted while parsing sending friend keys");
+                    }
+                }
+
+                wallet.addWatchedScripts(scripts);
+                if (walletProto.hasDescription()) {
+                    wallet.setDescription(walletProto.getDescription());
+                }
 
-        //read the keys for friends (they send, we spend)
+                // load extensions before processing transactions
+                long extStart = System.currentTimeMillis();
+                loadExtensions(wallet, extensions != null ? extensions : new WalletExtension[0], walletProto);
+                long extTime = System.currentTimeMillis() - extStart;
+                log.info("readWallet: loadExtensions done in {}ms", extTime);
+
+                long connectTime = 0;
+                if (forceReset) {
+                    wallet.setLastBlockSeenHash(null);
+                    wallet.setLastBlockSeenHeight(-1);
+                    wallet.setLastBlockSeenTimeSecs(0);
+                } else {
+                    // Wait for all transaction futures, then populate txMap
+                    if (!txFutures.isEmpty()) {
+                        try {
+                            CompletableFuture.allOf(txFutures.toArray(new CompletableFuture[0])).get();
+                        } catch (ExecutionException e) {
+                            Throwable cause = e.getCause();
+                            if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
+                                throw (UnreadableWalletException) cause.getCause();
+                            if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                            throw new UnreadableWalletException("Failed to parse transactions", e);
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                            throw new UnreadableWalletException("Interrupted while parsing transactions");
+                        }
+                    }
+                    txTime[0] = System.currentTimeMillis() - txFuturesStart;
+                    log.info("readWallet: tx threads done in {}ms ({} transactions)", txTime[0], parsedTxs.size());
+                    txMap.putAll(parsedTxs);
+
+                    // Connect outputs in parallel: txMap is fully populated and read-only here.
+                    // Each call only touches its own tx's outputs and unique inputs of spending txs,
+                    // so concurrent calls do not write to the same fields.
+                    long connectStart = System.currentTimeMillis();
+                    List<Protos.Transaction> txProtoList = walletProto.getTransactionList();
+                    final WalletTransaction[] walletTxns = new WalletTransaction[txProtoList.size()];
+                    List<CompletableFuture<Void>> connectFutures = new ArrayList<>(txProtoList.size());
+                    for (int i = 0; i < txProtoList.size(); i++) {
+                        final int idx = i;
+                        final Protos.Transaction txProto = txProtoList.get(idx);
+                        connectFutures.add(CompletableFuture.runAsync(() -> {
+                            try {
+                                walletTxns[idx] = connectTransactionOutputs(params, txProto);
+                            } catch (UnreadableWalletException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }, executor));
+                    }
+                    try {
+                        CompletableFuture.allOf(connectFutures.toArray(new CompletableFuture[0])).get();
+                    } catch (ExecutionException e) {
+                        Throwable cause = e.getCause();
+                        if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
+                            throw (UnreadableWalletException) cause.getCause();
+                        if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                        throw new UnreadableWalletException("Failed to connect transaction outputs", e);
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        throw new UnreadableWalletException("Interrupted while connecting transaction outputs");
+                    }
+                    connectTime = System.currentTimeMillis() - connectStart;
+                    log.info("readWallet: connectOutputs done in {}ms (parallel)", connectTime);
+
+                    // Add to wallet sequentially (addWalletTransaction acquires write lock per call)
+                    for (WalletTransaction wtx : walletTxns) {
+                        wallet.addWalletTransaction(wtx);
+                    }
 
-        if(walletProto.getKeysForFriendsCount() > 0) {
-            KeyCrypter keyCrypter = null;
-            FriendKeyChainGroup friendKeyChainGroup = null;
+                    if (!walletProto.hasLastSeenBlockHash()) {
+                        wallet.setLastBlockSeenHash(null);
+                    } else {
+                        wallet.setLastBlockSeenHash(byteStringToHash(walletProto.getLastSeenBlockHash()));
+                    }
+                    if (!walletProto.hasLastSeenBlockHeight()) {
+                        wallet.setLastBlockSeenHeight(-1);
+                    } else {
+                        wallet.setLastBlockSeenHeight(walletProto.getLastSeenBlockHeight());
+                    }
+                    wallet.setLastBlockSeenTimeSecs(walletProto.getLastSeenBlockTimeSecs());
+                    if (walletProto.hasKeyRotationTime()) {
+                        wallet.setKeyRotationTime(new Date(walletProto.getKeyRotationTime() * 1000));
+                    }
+                }
+
+                for (Protos.Tag tag : walletProto.getTagsList()) {
+                    wallet.setTag(tag.getTag(), tag.getData());
+                }
+                if (walletProto.hasVersion()) {
+                    wallet.setVersion(walletProto.getVersion());
+                }
+
+                txMap.clear();
+                long totalTime = System.currentTimeMillis() - methodStart;
+                log.info("readWallet (parallel={}) timing: {}ms total, keys={}ms, friendRecv={}ms, friendSend={}ms, tx={}ms[{}tx], ext={}ms, connect={}ms",
+                        complexityScore, totalTime, keysTime[0], friendRecvTime[0], friendSendTime[0],
+                        txTime[0], walletProto.getTransactionCount(), extTime, connectTime);
+                return wallet;
+            } finally {
+                executor.shutdown();
+            }
+        } else {
+            // Serial path for small wallets
+            // Read the scrypt parameters that specify how encryption and decryption is performed.
+            KeyChainGroup keyChainGroup;
             if (walletProto.hasEncryptionParameters()) {
                 Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
-                keyCrypter = new KeyCrypterScrypt(encryptionParameters);
-                friendKeyChainGroup = FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysForFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
+                final KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
+                keyChainGroup = KeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeyList(), keyCrypter, keyChainFactory);
             } else {
-                friendKeyChainGroup = FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysForFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
+                keyChainGroup = KeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeyList(), keyChainFactory);
             }
-            wallet.setReceivingFromFriendsGroup(friendKeyChainGroup);
-        }
+            Wallet wallet = factory.create(params, keyChainGroup);
 
-        if(walletProto.getKeysFromFriendsCount() > 0) {
-            KeyCrypter keyCrypter = null;
-            FriendKeyChainGroup friendKeyChainGroup = null;
-            if (walletProto.hasEncryptionParameters()) {
-                Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
-                keyCrypter = new KeyCrypterScrypt(encryptionParameters);
-                friendKeyChainGroup = FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysFromFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
-            } else {
-                friendKeyChainGroup = FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysFromFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
+            List<Script> scripts = Lists.newArrayList();
+            for (Protos.Script protoScript : walletProto.getWatchedScriptList()) {
+                try {
+                    Script script =
+                            new Script(protoScript.getProgram().toByteArray(),
+                                    protoScript.getCreationTimestamp() / 1000);
+                    scripts.add(script);
+                } catch (ScriptException e) {
+                    throw new UnreadableWalletException("Unparseable script in wallet");
+                }
             }
-            wallet.setSendingToFriendsGroup(friendKeyChainGroup);
-        }
 
-        wallet.addWatchedScripts(scripts);
+            //read the keys for friends (they send, we spend)
+            if (walletProto.getKeysForFriendsCount() > 0) {
+                FriendKeyChainGroup friendKeyChainGroup;
+                if (walletProto.hasEncryptionParameters()) {
+                    Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
+                    KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
+                    friendKeyChainGroup = FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysForFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
+                } else {
+                    friendKeyChainGroup = FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysForFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
+                }
+                wallet.setReceivingFromFriendsGroup(friendKeyChainGroup);
+            }
 
-        if (walletProto.hasDescription()) {
-            wallet.setDescription(walletProto.getDescription());
-        }
+            if (walletProto.getKeysFromFriendsCount() > 0) {
+                FriendKeyChainGroup friendKeyChainGroup;
+                if (walletProto.hasEncryptionParameters()) {
+                    Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
+                    KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
+                    friendKeyChainGroup = FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysFromFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
+                } else {
+                    friendKeyChainGroup = FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysFromFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
+                }
+                wallet.setSendingToFriendsGroup(friendKeyChainGroup);
+            }
 
-        // load extensions before processing transactions
-        loadExtensions(wallet, extensions != null ? extensions : new WalletExtension[0], walletProto);
+            wallet.addWatchedScripts(scripts);
 
-        if (forceReset) {
-            // Should mirror Wallet.reset()
-            wallet.setLastBlockSeenHash(null);
-            wallet.setLastBlockSeenHeight(-1);
-            wallet.setLastBlockSeenTimeSecs(0);
-        } else {
-            // Read all transactions and insert into the txMap.
-            for (Protos.Transaction txProto : walletProto.getTransactionList()) {
-                readTransaction(txProto, wallet.getParams());
+            if (walletProto.hasDescription()) {
+                wallet.setDescription(walletProto.getDescription());
             }
 
-            // Update transaction outputs to point to inputs that spend them
-            for (Protos.Transaction txProto : walletProto.getTransactionList()) {
-                WalletTransaction wtx = connectTransactionOutputs(params, txProto);
-                wallet.addWalletTransaction(wtx);
-            }
+            // load extensions before processing transactions
+            loadExtensions(wallet, extensions != null ? extensions : new WalletExtension[0], walletProto);
 
-            // Update the lastBlockSeenHash.
-            if (!walletProto.hasLastSeenBlockHash()) {
+            if (forceReset) {
+                // Should mirror Wallet.reset()
                 wallet.setLastBlockSeenHash(null);
-            } else {
-                wallet.setLastBlockSeenHash(byteStringToHash(walletProto.getLastSeenBlockHash()));
-            }
-            if (!walletProto.hasLastSeenBlockHeight()) {
                 wallet.setLastBlockSeenHeight(-1);
+                wallet.setLastBlockSeenTimeSecs(0);
             } else {
-                wallet.setLastBlockSeenHeight(walletProto.getLastSeenBlockHeight());
-            }
-            // Will default to zero if not present.
-            wallet.setLastBlockSeenTimeSecs(walletProto.getLastSeenBlockTimeSecs());
+                // Read all transactions and insert into the txMap.
+                for (Protos.Transaction txProto : walletProto.getTransactionList()) {
+                    readTransaction(txProto, wallet.getParams());
+                }
+
+                // Update transaction outputs to point to inputs that spend them
+                for (Protos.Transaction txProto : walletProto.getTransactionList()) {
+                    WalletTransaction wtx = connectTransactionOutputs(params, txProto);
+                    wallet.addWalletTransaction(wtx);
+                }
+
+                // Update the lastBlockSeenHash.
+                if (!walletProto.hasLastSeenBlockHash()) {
+                    wallet.setLastBlockSeenHash(null);
+                } else {
+                    wallet.setLastBlockSeenHash(byteStringToHash(walletProto.getLastSeenBlockHash()));
+                }
+                if (!walletProto.hasLastSeenBlockHeight()) {
+                    wallet.setLastBlockSeenHeight(-1);
+                } else {
+                    wallet.setLastBlockSeenHeight(walletProto.getLastSeenBlockHeight());
+                }
+                // Will default to zero if not present.
+                wallet.setLastBlockSeenTimeSecs(walletProto.getLastSeenBlockTimeSecs());
 
-            if (walletProto.hasKeyRotationTime()) {
-                wallet.setKeyRotationTime(new Date(walletProto.getKeyRotationTime() * 1000));
+                if (walletProto.hasKeyRotationTime()) {
+                    wallet.setKeyRotationTime(new Date(walletProto.getKeyRotationTime() * 1000));
+                }
             }
-        }
 
-        for (Protos.Tag tag : walletProto.getTagsList()) {
-            wallet.setTag(tag.getTag(), tag.getData());
-        }
+            for (Protos.Tag tag : walletProto.getTagsList()) {
+                wallet.setTag(tag.getTag(), tag.getData());
+            }
 
-        if (walletProto.hasVersion()) {
-            wallet.setVersion(walletProto.getVersion());
-        }
+            if (walletProto.hasVersion()) {
+                wallet.setVersion(walletProto.getVersion());
+            }
 
-        // Make sure the object can be re-used to read another wallet without corruption.
-        txMap.clear();
+            // Make sure the object can be re-used to read another wallet without corruption.
+            txMap.clear();
 
-        return wallet;
+            return wallet;
+        }
     }
 
     private void loadExtensions(Wallet wallet, WalletExtension[] extensionsList, Protos.Wallet walletProto) throws UnreadableWalletException {
@@ -1057,7 +1313,7 @@ public static Protos.Wallet parseToProto(InputStream input) throws IOException {
         return Protos.Wallet.parseFrom(codedInput);
     }
 
-    private void readTransaction(Protos.Transaction txProto, NetworkParameters params) throws UnreadableWalletException {
+    private Transaction parseTransactionFromProto(Protos.Transaction txProto, NetworkParameters params) throws UnreadableWalletException {
         Transaction tx = new Transaction(params);
 
         tx.setVersion(txProto.getVersion());
@@ -1164,6 +1420,11 @@ private void readTransaction(Protos.Transaction txProto, NetworkParameters param
         Sha256Hash protoHash = byteStringToHash(txProto.getHash());
         if (!tx.getTxId().equals(protoHash))
             throw new UnreadableWalletException(String.format(Locale.US, "Transaction did not deserialize completely: %s vs %s", tx.getTxId(), protoHash));
+        return tx;
+    }
+
+    private void readTransaction(Protos.Transaction txProto, NetworkParameters params) throws UnreadableWalletException {
+        Transaction tx = parseTransactionFromProto(txProto, params);
         if (txMap.containsKey(txProto.getHash()))
             throw new UnreadableWalletException("Wallet contained duplicate transaction " + byteStringToHash(txProto.getHash()));
         txMap.put(txProto.getHash(), tx);

From c2b1771666cdafcfce0cbd29e7ba69f83fb587be Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Wed, 18 Mar 2026 21:12:14 -0700
Subject: [PATCH 04/22] fix: reduce processing for non-wallet transactions

---
 .../bitcoinj/quorums/InstantSendManager.java  | 68 +++++++++++--------
 1 file changed, 39 insertions(+), 29 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
index a07ee6d4d0..a626f714d7 100644
--- a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
+++ b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
@@ -189,9 +189,10 @@ public void processInstantSendLock(Peer peer, InstantSendLock isLock) {
             return;
         }
 
-        context.getConfidenceTable().seen(isLock.txid, peer.getAddress());
-        TransactionConfidence confidence = context.getConfidenceTable().getOrCreate(isLock.txid);
-        if (confidence != null) {
+        Transaction walletTx = getWalletTransaction(isLock.txid);
+        if (walletTx != null) {
+            context.getConfidenceTable().seen(isLock.txid, peer.getAddress());
+            TransactionConfidence confidence = walletTx.getConfidence();
             if (confidence.getIXType() != TransactionConfidence.IXType.IX_NONE) {
                 return;
             }
@@ -294,10 +295,6 @@ public boolean alreadyHave(InventoryItem inv)
         lock.lock();
         try {
             boolean haslock = db.getInstantSendLockByHash(inv.hash) != null || pendingInstantSendLocks.containsKey(inv.hash);
-            TransactionConfidence confidence = context.getConfidenceTable().get(inv.hash);
-            if (confidence != null && confidence.getIXType() != TransactionConfidence.IXType.IX_NONE) {
-                return true;
-            }
             if (!invalidInstantSendLocks.isEmpty()) {
                 for (InstantSendLock islock : invalidInstantSendLocks.keySet()) {
                     if(inv.hash.equals(islock.getHash()))
@@ -355,9 +352,8 @@ boolean checkCanLock(TransactionOutPoint outpoint, boolean printDebug, Sha256Has
             return true;
         }
 
-        TxConfidenceTable mempool = context.getConfidenceTable();
-        TransactionConfidence mempoolTx = mempool.get(outpoint.getHash());
-        if (mempoolTx != null) {
+        Transaction parentTx = getWalletTransaction(outpoint.getHash());
+        if (parentTx != null && parentTx.getConfidence().getConfidenceType() == TransactionConfidence.ConfidenceType.PENDING) {
             if (printDebug) {
                 log.info("txid={}: parent mempool TX {} is not locked", txHash, outpoint.getHash());
             }
@@ -651,7 +647,9 @@ HashSet<Sha256Hash> processPendingInstantSendLocks(LLMQParameters.LLMQType llmqT
                 // testing again means that we might be a block behind or something
                 // for now, let us not save this to be retested forever...
                 // invalidInstantSendLocks.put(islock, Utils.currentTimeSeconds());
-                TransactionConfidence confidence = context.getConfidenceTable().getOrCreate(islock.txid);
+                Transaction failedTx = getWalletTransaction(islock.txid);
+                TransactionConfidence confidence = failedTx != null ? failedTx.getConfidence()
+                        : context.getConfidenceTable().get(islock.txid);
                 if (confidence != null) {
                     log.info("islock: set to IX_LOCK_FAILED for {}", islock.txid);
                     confidence.setIXType(TransactionConfidence.IXType.IX_LOCK_FAILED);
@@ -686,7 +684,7 @@ void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
     {
         StoredBlock minedBlock = null;
 
-        TransactionConfidence confidence = context.getConfidenceTable().getOrCreate(hash);
+        TransactionConfidence confidence = context.getConfidenceTable().get(islock.txid);
         if (confidence != null && confidence.getConfidenceType() == TransactionConfidence.ConfidenceType.BUILDING) {
             long height = confidence.getAppearedAtChainHeight();
 
@@ -738,8 +736,7 @@ void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
             // If an ISLOCK was originally invalid, but was later validated.
             // remove it here
             //
-            if(invalidInstantSendLocks.containsKey(islock))
-                invalidInstantSendLocks.remove(islock);
+            invalidInstantSendLocks.remove(islock);
         } finally {
             lock.unlock();
         }
@@ -749,15 +746,28 @@ void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
     }
 
     void updateWalletTransaction(Sha256Hash txid, Transaction tx) {
-        TransactionConfidence confidence = tx != null ? tx.getConfidence() : context.getConfidenceTable().getOrCreate(txid);
-        if (confidence != null) {
-            scheduledExecutorService.schedule(() -> {
-                confidence.setIXType(TransactionConfidence.IXType.IX_LOCKED);
-                confidence.queueListeners(TransactionConfidence.Listener.ChangeReason.IX_TYPE);
-            }, 250, TimeUnit.MILLISECONDS);
-        } else {
-            log.info("confidence for {} not found", txid);
+        Transaction walletTx = tx;
+        if (walletTx == null) {
+            walletTx = getWalletTransaction(txid);
+        }
+        if (walletTx == null) {
+            log.debug("ignoring ISLock for txid {} — not a wallet transaction", txid);
+            return;
         }
+        TransactionConfidence confidence = walletTx.getConfidence();
+        scheduledExecutorService.schedule(() -> {
+            confidence.setIXType(TransactionConfidence.IXType.IX_LOCKED);
+            confidence.queueListeners(TransactionConfidence.Listener.ChangeReason.IX_TYPE);
+        }, 250, TimeUnit.MILLISECONDS);
+    }
+
+    @Nullable
+    private Transaction getWalletTransaction(Sha256Hash txid) {
+        for (Wallet wallet : wallets) {
+            Transaction tx = wallet.getTransaction(txid);
+            if (tx != null) return tx;
+        }
+        return null;
     }
 
     public void syncTransaction(Transaction tx, StoredBlock block, int posInBlock) {
@@ -800,6 +810,12 @@ public void syncTransaction(Transaction tx, StoredBlock block, int posInBlock) {
         } finally {
             lock.unlock();
         }
+
+        // If an ISLock was received before this transaction arrived in the wallet,
+        // apply it now that the transaction is known.
+        if (!isDisconnect && islockHash != null && !islockHash.isZero()) {
+            updateWalletTransaction(tx.getTxId(), tx);
+        }
     }
 
     ChainLockListener chainLockListener = block -> handleFullyConfirmedBlock(block.getHeight());
@@ -994,13 +1010,7 @@ public boolean notifyTransactionIsInBlock(Sha256Hash txHash, StoredBlock block,
         }
     };
 
-    //TODO: finish connecting this.  Should we keep a list of transactions sent and received in spv mode?
-    OnTransactionBroadcastListener transactionBroadcastListener = new OnTransactionBroadcastListener() {
-        @Override
-        public void onTransaction(Peer peer, Transaction t) {
-            syncTransaction(t, null, -1);
-        }
-    };
+    OnTransactionBroadcastListener transactionBroadcastListener = (peer, t) -> syncTransaction(t, null, -1);
 
     WalletCoinsSentEventListener coinsSentEventListener = (wallet, tx, prevBalance, newBalance) -> syncTransaction(tx, null, -1);
 

From 54be7d14e751da1cc52ff8a4a9fa8f44fc12a35a Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Wed, 18 Mar 2026 21:12:33 -0700
Subject: [PATCH 05/22] fix: add DashSystem.removeWallet

---
 core/src/main/java/org/bitcoinj/manager/DashSystem.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/core/src/main/java/org/bitcoinj/manager/DashSystem.java b/core/src/main/java/org/bitcoinj/manager/DashSystem.java
index 2680ecff8f..3207d77e55 100644
--- a/core/src/main/java/org/bitcoinj/manager/DashSystem.java
+++ b/core/src/main/java/org/bitcoinj/manager/DashSystem.java
@@ -444,4 +444,8 @@ public void triggerMnListDownloadComplete() {
     public void addWallet(Wallet wallet) {
         instantSendManager.addWallet(wallet);
     }
+
+    public void removeWallet(Wallet wallet) {
+        instantSendManager.removeWallet(wallet);
+    }
 }

From 5b4273d812076390819cd0e3719c63f9a67779e9 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 20 Mar 2026 17:33:46 -0700
Subject: [PATCH 06/22] fix: allow OP_RETURN with 0.00 value in
 DefaultRiskAnalysis.isOutputStandard

---
 .../main/java/org/bitcoinj/wallet/DefaultRiskAnalysis.java    | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/core/src/main/java/org/bitcoinj/wallet/DefaultRiskAnalysis.java b/core/src/main/java/org/bitcoinj/wallet/DefaultRiskAnalysis.java
index c633583fa4..f5b9666cca 100644
--- a/core/src/main/java/org/bitcoinj/wallet/DefaultRiskAnalysis.java
+++ b/core/src/main/java/org/bitcoinj/wallet/DefaultRiskAnalysis.java
@@ -28,6 +28,7 @@
 import org.bitcoinj.core.TransactionOutput;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.script.ScriptChunk;
+import org.bitcoinj.script.ScriptPattern;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -170,6 +171,9 @@ public static RuleViolation isStandard(Transaction tx) {
      * Checks the output to see if the script violates a standardness rule. Not complete.
      */
     public static RuleViolation isOutputStandard(TransactionOutput output) {
+        // OP_RETURN outputs are unspendable data-carrier outputs; zero value is standard for them.
+        if (ScriptPattern.isOpReturn(output.getScriptPubKey()))
+            return RuleViolation.NONE;
         if (output.getValue().compareTo(MIN_ANALYSIS_NONDUST_OUTPUT) < 0)
             return RuleViolation.DUST;
         for (ScriptChunk chunk : output.getScriptPubKey().getChunks()) {

From 3bfe56f83f555e62ca071472f03026be44faeab5 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 20 Mar 2026 17:34:38 -0700
Subject: [PATCH 07/22] fix: use CopyOnWriteArrayList for wallet list in
 InstantSendManager

---
 .../src/main/java/org/bitcoinj/quorums/InstantSendManager.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
index a626f714d7..e6444d519f 100644
--- a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
+++ b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
@@ -32,6 +32,7 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
@@ -55,7 +56,7 @@ public class InstantSendManager implements RecoveredSignatureListener {
     private final boolean runWithoutThread;
     private ScheduledExecutorService scheduledExecutorService;
     private AbstractBlockChain blockChain;
-    private final ArrayList<Wallet> wallets = new ArrayList<>();
+    private final CopyOnWriteArrayList<Wallet> wallets = new CopyOnWriteArrayList<>();
 
     //Keep track of when the ISLOCK arrived
     HashMap<InstantSendLock, Long> invalidInstantSendLocks;

From 957b340049992e9c1c51675d6787a85a0e001626 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:11:19 -0700
Subject: [PATCH 08/22] fix: add parallelization to reading a wallet (protobuf)

---
 .../wallet/WalletProtobufSerializer.java      | 82 ++++++++++++------
 .../wallet/LargeCoinJoinWalletTest.java       | 84 +++++++++++++++++++
 2 files changed, 142 insertions(+), 24 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
index 81fc56e94a..4d1d0928d1 100644
--- a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
+++ b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
@@ -102,6 +102,7 @@ public class WalletProtobufSerializer {
     private boolean requireAllExtensionsKnown = false;
     private int walletWriteBufferSize = CodedOutputStream.DEFAULT_BUFFER_SIZE;
     private boolean useAdaptiveBufferSizing = true;
+    private boolean parallelLoad = true;
 
     public interface WalletFactory {
         Wallet create(NetworkParameters params, KeyChainGroup keyChainGroup);
@@ -164,6 +165,21 @@ public void setUseAdaptiveBufferSizing(boolean useAdaptiveBufferSizing) {
         this.useAdaptiveBufferSizing = useAdaptiveBufferSizing;
     }
 
+    /**
+     * Enable or disable parallel loading of large wallets. When enabled, key chain parsing and
+     * transaction deserialization are performed concurrently across multiple threads.
+     * Disable this if benchmarking or if parallel loading is slower on the target device.
+     * Default is true.
+     * @param parallelLoad true to enable parallel loading, false to use single-threaded loading
+     */
+    public void setParallelLoad(boolean parallelLoad) {
+        this.parallelLoad = parallelLoad;
+    }
+
+    public boolean isParallelLoad() {
+        return parallelLoad;
+    }
+
     /**
      * Calculate optimal buffer size based on wallet characteristics.
      * Small wallets: 8KB, Medium wallets: 16KB, Large wallets: 64KB+
@@ -911,15 +927,17 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
 
         long methodStart = System.currentTimeMillis();
         int complexityScore = getProtoComplexityScore(walletProto);
-        boolean isLargeWallet = complexityScore > 10_000;
+        boolean isLargeWallet = parallelLoad && complexityScore > 10_000;
 
         if (isLargeWallet) {
-            final long[] keysTime = {0}, friendRecvTime = {0}, friendSendTime = {0}, txTime = {0};
+            final long[] keysTime = {0}, friendRecvTime = {0}, friendSendTime = {0}, txTime = {0}, addWalletTime = {0};
             final boolean hasEncryption = walletProto.hasEncryptionParameters();
             final KeyCrypterScrypt keyCrypter = hasEncryption ?
                     new KeyCrypterScrypt(walletProto.getEncryptionParameters()) : null;
 
-            ExecutorService executor = Executors.newFixedThreadPool(4,
+            int numThreads = Math.min(Runtime.getRuntime().availableProcessors(), 8);
+            // +3 extra threads so keys/friendRecv/friendSend don't compete with tx batch threads
+            ExecutorService executor = Executors.newFixedThreadPool(numThreads + 3,
                     new ContextPropagatingThreadFactory("wallet-deserializer"));
             try {
                 // Future 1: Parse key chain group (most expensive)
@@ -976,21 +994,31 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
                     }, executor);
                 }
 
-                // Futures 4+: Parse each transaction independently (no txMap writes yet)
+                // Parse transactions in batches (one future per thread) to avoid per-tx future overhead
                 Map<ByteString, Transaction> parsedTxs = new ConcurrentHashMap<>();
                 List<CompletableFuture<Void>> txFutures = new ArrayList<>();
                 long txFuturesStart = System.currentTimeMillis();
                 if (!forceReset) {
-                    log.info("readWallet: tx threads starting ({} transactions)", walletProto.getTransactionCount());
-                    for (Protos.Transaction txProto : walletProto.getTransactionList()) {
+                    List<Protos.Transaction> allTxProtos = walletProto.getTransactionList();
+                    // Use total pool size as batch count so freed key/friend threads can pick up tx work
+                    int txBatchCount = numThreads + 3;
+                    int txBatchSize = Math.max(1, (allTxProtos.size() + txBatchCount - 1) / txBatchCount);
+                    log.info("readWallet: tx threads starting ({} transactions, batchCount={}, batchSize={})",
+                            allTxProtos.size(), txBatchCount, txBatchSize);
+                    for (int i = 0; i < allTxProtos.size(); i += txBatchSize) {
+                        final int from = i;
+                        final int to = Math.min(i + txBatchSize, allTxProtos.size());
                         txFutures.add(CompletableFuture.runAsync(() -> {
-                            try {
-                                Transaction tx = parseTransactionFromProto(txProto, params);
-                                if (parsedTxs.putIfAbsent(txProto.getHash(), tx) != null)
-                                    throw new RuntimeException(new UnreadableWalletException(
-                                            "Wallet contained duplicate transaction " + byteStringToHash(txProto.getHash())));
-                            } catch (UnreadableWalletException e) {
-                                throw new RuntimeException(e);
+                            for (int j = from; j < to; j++) {
+                                Protos.Transaction txProto = allTxProtos.get(j);
+                                try {
+                                    Transaction tx = parseTransactionFromProto(txProto, params);
+                                    if (parsedTxs.putIfAbsent(txProto.getHash(), tx) != null)
+                                        throw new RuntimeException(new UnreadableWalletException(
+                                                "Wallet contained duplicate transaction " + byteStringToHash(txProto.getHash())));
+                                } catch (UnreadableWalletException e) {
+                                    throw new RuntimeException(e);
+                                }
                             }
                         }, executor));
                     }
@@ -1089,15 +1117,18 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
                     long connectStart = System.currentTimeMillis();
                     List<Protos.Transaction> txProtoList = walletProto.getTransactionList();
                     final WalletTransaction[] walletTxns = new WalletTransaction[txProtoList.size()];
-                    List<CompletableFuture<Void>> connectFutures = new ArrayList<>(txProtoList.size());
-                    for (int i = 0; i < txProtoList.size(); i++) {
-                        final int idx = i;
-                        final Protos.Transaction txProto = txProtoList.get(idx);
+                    int connectBatchSize = Math.max(1, (txProtoList.size() + numThreads + 2) / (numThreads + 3));
+                    List<CompletableFuture<Void>> connectFutures = new ArrayList<>(numThreads);
+                    for (int i = 0; i < txProtoList.size(); i += connectBatchSize) {
+                        final int from = i;
+                        final int to = Math.min(i + connectBatchSize, txProtoList.size());
                         connectFutures.add(CompletableFuture.runAsync(() -> {
-                            try {
-                                walletTxns[idx] = connectTransactionOutputs(params, txProto);
-                            } catch (UnreadableWalletException e) {
-                                throw new RuntimeException(e);
+                            for (int j = from; j < to; j++) {
+                                try {
+                                    walletTxns[j] = connectTransactionOutputs(params, txProtoList.get(j));
+                                } catch (UnreadableWalletException e) {
+                                    throw new RuntimeException(e);
+                                }
                             }
                         }, executor));
                     }
@@ -1117,9 +1148,12 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
                     log.info("readWallet: connectOutputs done in {}ms (parallel)", connectTime);
 
                     // Add to wallet sequentially (addWalletTransaction acquires write lock per call)
+                    long addWalletStart = System.currentTimeMillis();
                     for (WalletTransaction wtx : walletTxns) {
                         wallet.addWalletTransaction(wtx);
                     }
+                    addWalletTime[0] = System.currentTimeMillis() - addWalletStart;
+                    log.info("readWallet: addWalletTransactions done in {}ms ({} txs)", addWalletTime[0], walletTxns.length);
 
                     if (!walletProto.hasLastSeenBlockHash()) {
                         wallet.setLastBlockSeenHash(null);
@@ -1146,9 +1180,9 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
 
                 txMap.clear();
                 long totalTime = System.currentTimeMillis() - methodStart;
-                log.info("readWallet (parallel={}) timing: {}ms total, keys={}ms, friendRecv={}ms, friendSend={}ms, tx={}ms[{}tx], ext={}ms, connect={}ms",
-                        complexityScore, totalTime, keysTime[0], friendRecvTime[0], friendSendTime[0],
-                        txTime[0], walletProto.getTransactionCount(), extTime, connectTime);
+                log.info("readWallet (parallel={}, threads={}) timing: {}ms total, keys={}ms, friendRecv={}ms, friendSend={}ms, tx={}ms[{}tx], ext={}ms, connect={}ms, addWallet={}ms",
+                        complexityScore, numThreads, totalTime, keysTime[0], friendRecvTime[0], friendSendTime[0],
+                        txTime[0], walletProto.getTransactionCount(), extTime, connectTime, addWalletTime[0]);
                 return wallet;
             } finally {
                 executor.shutdown();
diff --git a/core/src/test/java/org/bitcoinj/wallet/LargeCoinJoinWalletTest.java b/core/src/test/java/org/bitcoinj/wallet/LargeCoinJoinWalletTest.java
index ba28517ba2..6aea2120c0 100644
--- a/core/src/test/java/org/bitcoinj/wallet/LargeCoinJoinWalletTest.java
+++ b/core/src/test/java/org/bitcoinj/wallet/LargeCoinJoinWalletTest.java
@@ -518,6 +518,90 @@ public void walletConsistencyAndCachingPerformanceTest() throws IOException, Unr
         }
     }
 
+    @Test
+    public void walletLoadPerformanceTest() throws IOException, UnreadableWalletException {
+        info("=== Wallet Load Performance Test (serial vs parallel) ===");
+
+        // Serialize the wallet once so we reload from identical bytes each time
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        new WalletProtobufSerializer().writeWallet(wallet, baos);
+        final byte[] walletBytes = baos.toByteArray();
+        info("Wallet serialized: {} bytes", walletBytes.length);
+
+        int warmupRuns = 2;
+        int timedRuns = 5;
+
+        // --- Serial ---
+        WalletProtobufSerializer serialSerializer = new WalletProtobufSerializer();
+        serialSerializer.setParallelLoad(false);
+
+        for (int i = 0; i < warmupRuns; i++) {
+            serialSerializer.readWallet(new ByteArrayInputStream(walletBytes));
+        }
+
+        long[] serialTimes = new long[timedRuns];
+        for (int i = 0; i < timedRuns; i++) {
+            Stopwatch w = Stopwatch.createStarted();
+            WalletEx loaded = (WalletEx) serialSerializer.readWallet(new ByteArrayInputStream(walletBytes));
+            serialTimes[i] = w.elapsed().toMillis();
+            assertEquals(wallet.getTransactionCount(true), loaded.getTransactionCount(true));
+            assertEquals(wallet.getBalance(Wallet.BalanceType.ESTIMATED), loaded.getBalance(Wallet.BalanceType.ESTIMATED));
+        }
+
+        // --- Parallel ---
+        WalletProtobufSerializer parallelSerializer = new WalletProtobufSerializer();
+        parallelSerializer.setParallelLoad(true);
+
+        for (int i = 0; i < warmupRuns; i++) {
+            parallelSerializer.readWallet(new ByteArrayInputStream(walletBytes));
+        }
+
+        long[] parallelTimes = new long[timedRuns];
+        for (int i = 0; i < timedRuns; i++) {
+            Stopwatch w = Stopwatch.createStarted();
+            WalletEx loaded = (WalletEx) parallelSerializer.readWallet(new ByteArrayInputStream(walletBytes));
+            parallelTimes[i] = w.elapsed().toMillis();
+            assertEquals(wallet.getTransactionCount(true), loaded.getTransactionCount(true));
+            assertEquals(wallet.getBalance(Wallet.BalanceType.ESTIMATED), loaded.getBalance(Wallet.BalanceType.ESTIMATED));
+        }
+
+        long serialAvg = average(serialTimes);
+        long serialMin = min(serialTimes);
+        long parallelAvg = average(parallelTimes);
+        long parallelMin = min(parallelTimes);
+
+        info("Serial   avg={}ms  min={}ms  runs={}", serialAvg, serialMin, formatTimes(serialTimes));
+        info("Parallel avg={}ms  min={}ms  runs={}", parallelAvg, parallelMin, formatTimes(parallelTimes));
+
+        if (parallelAvg < serialAvg) {
+            double speedup = (double) serialAvg / parallelAvg;
+            info("Parallel is {:.2f}x faster (avg)", speedup);
+        } else {
+            info("Serial is faster on this device — consider setParallelLoad(false)");
+        }
+    }
+
+    private static long average(long[] times) {
+        long sum = 0;
+        for (long t : times) sum += t;
+        return sum / times.length;
+    }
+
+    private static long min(long[] times) {
+        long m = times[0];
+        for (long t : times) if (t < m) m = t;
+        return m;
+    }
+
+    private static String formatTimes(long[] times) {
+        StringBuilder sb = new StringBuilder("[");
+        for (int i = 0; i < times.length; i++) {
+            if (i > 0) sb.append(", ");
+            sb.append(times[i]).append("ms");
+        }
+        return sb.append("]").toString();
+    }
+
     @Test
     public void walletProtoSaveTest() {
         WalletProtobufSerializer serializer = new WalletProtobufSerializer();

From 41413cd7bc9b1f910fccdc4863fef5d70c7697e5 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:13:32 -0700
Subject: [PATCH 09/22] fix: update Testnet masternode lists and add a
 masternode update python script

---
 .gitignore                                    |   3 +-
 .../org/bitcoinj/params/TestNet3Params.java   | 145 +++++++-----------
 .../discovery/MasternodeSeedPeersTest.java    |   6 +-
 tools/src/main/python/update_masternodes.py   | 118 ++++++++++++++
 4 files changed, 180 insertions(+), 92 deletions(-)
 create mode 100644 tools/src/main/python/update_masternodes.py

diff --git a/.gitignore b/.gitignore
index 0f5791160e..00cb4c6b72 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,4 +25,5 @@ checkpoints-krupnik.txt
 /*.chainlocks
 *.gobjects
 /*.log
-.DS_Store
\ No newline at end of file
+.DS_Store
+*.inventory
\ No newline at end of file
diff --git a/core/src/main/java/org/bitcoinj/params/TestNet3Params.java b/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
index cc738120d7..95f5845318 100644
--- a/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
+++ b/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
@@ -177,92 +177,65 @@ public String getPaymentProtocolId() {
     }
 
     public static String[] MASTERNODES = {
-        "54.213.94.216",
-        "35.165.156.159",
-        "35.90.157.206",
-        "35.91.197.218",
-        "54.212.91.148",
-        "54.202.231.195",
-        "35.88.122.202",
-        "54.186.145.18",
-        "35.90.193.169",
-        "34.212.161.186",
-        "34.220.155.3",
-        "54.212.138.75",
-        "54.188.69.89",
-        "54.190.131.8",
-        "34.220.194.253",
-        "54.191.28.44",
-        "35.87.238.118",
-        "35.90.217.208",
-        "34.220.243.24",
-        "35.161.222.74",
-        "54.190.61.70",
-        "34.210.26.195",
-        "34.217.191.164",
-        "54.189.125.235",
-        "34.220.175.29",
-        "52.36.20.123",
-        "54.185.69.133",
-        "54.68.48.149",
-        "34.210.84.163",
-        "54.202.190.181",
-        "35.91.239.75",
-        "34.222.21.14",
-        "34.220.134.30",
-        "35.90.252.3",
-        "35.89.166.118",
-        "18.237.170.32",
-        "35.162.18.116",
-        "35.91.208.56",
-        "34.219.33.231",
-        "52.34.250.214",
-        "35.91.134.89",
-        "50.112.58.114",
-        "54.191.146.137",
-        "34.218.66.37",
-        "34.221.196.103",
-        "35.91.157.30",
-        "34.221.102.51",
-        "18.237.165.242",
-        "52.37.61.9",
-        "54.212.89.127",
-        "34.209.238.228",
-        "35.92.143.7",
-        "35.89.113.195",
-        "52.12.54.89",
-        "34.219.153.30",
-        "34.215.171.237",
-        "54.70.243.3",
-        "54.184.126.25",
-        "34.222.85.18",
-        "34.221.252.179",
-        "35.85.33.152",
-        "54.200.220.105",
-        "54.245.75.47",
-        "54.214.59.174",
-        "35.164.77.177",
-        "35.89.66.84",
-        "35.91.150.34",
-        "35.92.219.124",
-        "34.222.82.127",
-        "34.220.171.156",
-        "35.90.42.64",
-        "35.89.53.128",
-        "35.93.151.188",
-        "34.211.172.212",
-        "34.220.118.79",
-        "34.220.187.233",
-        "34.220.85.81",
-        "35.167.165.224",
-        "34.210.26.93",
-        "35.90.53.180",
+        "68.67.122.30",
+        "68.67.122.31",
+        "68.67.122.32",
+        "68.67.122.33",
+        "68.67.122.34",
+        "68.67.122.35",
+        "68.67.122.36",
+        "68.67.122.37",
+        "68.67.122.38",
+        "68.67.122.39",
+        "68.67.122.40",
+        "68.67.122.41",
+        "68.67.122.42",
+        "68.67.122.43",
+        "68.67.122.44",
+        "68.67.122.45",
+        "68.67.122.46",
+        "68.67.122.47",
+        "68.67.122.48",
+        "68.67.122.49",
+        "68.67.122.50",
+        "68.67.122.51",
+        "68.67.122.52",
+        "68.67.122.53",
+        "68.67.122.54",
+        "68.67.122.55",
+        "68.67.122.56",
+        "68.67.122.57",
+        "68.67.122.58",
+        "68.67.122.59",
+        "68.67.122.60",
+        "68.67.122.61",
+        "68.67.122.62",
+        "68.67.122.63",
+        "68.67.122.64",
+        "68.67.122.65",
+        "68.67.122.66",
+        "68.67.122.67",
+        "68.67.122.68",
+        "68.67.122.69",
+        "68.67.122.70",
+        "68.67.122.71",
+        "68.67.122.72",
+        "68.67.122.73",
+        "68.67.122.74",
+        "68.67.122.75",
+        "68.67.122.76",
+        "68.67.122.77",
+        "68.67.122.78",
+        "68.67.122.79",
+        "68.67.122.80",
+        "68.67.122.81",
+        "68.67.122.82"
     };
 
     public String [] HP_MASTERNODES = {
         "34.214.48.68",
         "35.166.18.166",
-        "35.165.50.126",
+        "68.67.122.3",
         "52.42.202.128",
         "52.12.176.90",
         "44.233.44.95",
@@ -277,22 +250,18 @@ public String getPaymentProtocolId() {
         "52.40.219.41",
         "44.239.39.153",
         "54.149.33.167",
-        "35.164.23.245",
+        "68.67.122.18",
         "52.33.28.47",
         "52.43.86.231",
         "52.43.13.92",
-        "35.163.144.230",
+        "68.67.122.22",
         "52.89.154.48",
         "52.24.124.162",
         "44.227.137.77",
         "35.85.21.179",
         "54.187.14.232",
         "54.68.235.201",
-        "52.13.250.182",
-        "35.82.49.196",
-        "44.232.196.6",
-        "54.189.164.39",
-        "54.213.204.85",
+        "68.67.122.29"
     };
 
     @Override
diff --git a/core/src/test/java/org/bitcoinj/net/discovery/MasternodeSeedPeersTest.java b/core/src/test/java/org/bitcoinj/net/discovery/MasternodeSeedPeersTest.java
index e6d0cc3a5e..ae14d19f4c 100644
--- a/core/src/test/java/org/bitcoinj/net/discovery/MasternodeSeedPeersTest.java
+++ b/core/src/test/java/org/bitcoinj/net/discovery/MasternodeSeedPeersTest.java
@@ -72,9 +72,9 @@ public void getPeers_empty() {
     public void testnetDefaultLists() {
         TestNet3Params params = TestNet3Params.get();
         MasternodeSeedPeers seedPeers = new MasternodeSeedPeers(params);
-        assertEquals(80, params.getDefaultMasternodeList().length);
-        assertEquals(33, params.getDefaultHPMasternodeList().length);
-        assertEquals(80, seedPeers.getSeedAddrs().length);
+        assertEquals(53, params.getDefaultMasternodeList().length);
+        assertEquals(29, params.getDefaultHPMasternodeList().length);
+        assertEquals(53, seedPeers.getSeedAddrs().length);
     }
 
     @Test
diff --git a/tools/src/main/python/update_masternodes.py b/tools/src/main/python/update_masternodes.py
new file mode 100644
index 0000000000..c79a3ddbb0
--- /dev/null
+++ b/tools/src/main/python/update_masternodes.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""
+Reads an Ansible inventory file, extracts masternode and hp-masternode public IPs,
+and updates the MASTERNODES and HP_MASTERNODES arrays in TestNet3Params.java.
+
+Usage:
+    python3 update_masternodes.py [inventory_file] [java_file]
+
+Defaults:
+    inventory_file: testnet.inventory (relative to script location)
+    java_file:      ../../../../core/src/main/java/org/bitcoinj/params/TestNet3Params.java
+"""
+
+import re
+import sys
+import os
+
+
+def parse_inventory(inventory_path):
+    """Parse Ansible inventory and return sorted lists of (index, ip) for each node type."""
+    masternode_ips = {}
+    hp_masternode_ips = {}
+
+    with open(inventory_path) as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('[') or line.startswith('#'):
+                continue
+
+            # Match host definition lines (have ansible_host= or public_ip=)
+            if 'public_ip=' not in line:
+                continue
+
+            m = re.match(r'^(masternode|hp-masternode)-(\d+)\s+', line)
+            if not m:
+                continue
+
+            node_type = m.group(1)
+            node_num = int(m.group(2))
+
+            ip_match = re.search(r'public_ip=(\S+)', line)
+            if not ip_match:
+                continue
+            ip = ip_match.group(1)
+
+            if node_type == 'masternode':
+                masternode_ips[node_num] = ip
+            else:
+                hp_masternode_ips[node_num] = ip
+
+    masternodes = [ip for _, ip in sorted(masternode_ips.items())]
+    hp_masternodes = [ip for _, ip in sorted(hp_masternode_ips.items())]
+    return masternodes, hp_masternodes
+
+
+def build_java_array(ips, indent='        '):
+    """Build the body of a Java String array from a list of IPs."""
+    lines = []
+    for ip in ips:
+        lines.append(f'{indent}"{ip}",')
+    # Remove trailing comma from last entry
+    if lines:
+        lines[-1] = lines[-1].rstrip(',')
+    return '\n'.join(lines)
+
+
+def replace_array(java_source, array_name, new_ips):
+    """Replace the contents of a Java String array declaration."""
+    # Match: <modifiers> String[] ARRAY_NAME = {\n    ...entries...\n    };
+    pattern = re.compile(
+        r'((?:public\s+|private\s+|protected\s+|static\s+|final\s+)*'
+        r'String\s*\[\]\s*' + re.escape(array_name) + r'\s*=\s*\{)'
+        r'[^}]*'
+        r'(\s*\};)',
+        re.DOTALL
+    )
+
+    new_body = build_java_array(new_ips)
+    replacement = r'\1\n' + new_body + r'\n    \2'
+
+    result, count = pattern.subn(replacement, java_source)
+    if count == 0:
+        raise ValueError(f"Could not find array '{array_name}' in Java source.")
+    return result
+
+
+def main():
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    inventory_path = sys.argv[1] if len(sys.argv) > 1 else os.path.join(script_dir, 'testnet.inventory')
+    java_path = sys.argv[2] if len(sys.argv) > 2 else os.path.join(
+        script_dir,
+        '../../../../core/src/main/java/org/bitcoinj/params/TestNet3Params.java'
+    )
+
+    inventory_path = os.path.abspath(inventory_path)
+    java_path = os.path.abspath(java_path)
+
+    print(f"Inventory: {inventory_path}")
+    print(f"Java file: {java_path}")
+
+    masternodes, hp_masternodes = parse_inventory(inventory_path)
+    print(f"Found {len(masternodes)} masternodes, {len(hp_masternodes)} hp-masternodes")
+
+    with open(java_path) as f:
+        source = f.read()
+
+    source = replace_array(source, 'MASTERNODES', masternodes)
+    source = replace_array(source, 'HP_MASTERNODES', hp_masternodes)
+
+    with open(java_path, 'w') as f:
+        f.write(source)
+
+    print("TestNet3Params.java updated successfully.")
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From 941d1dd4d1d8ee7a6581a660f01008290bb8b0d4 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:13:53 -0700
Subject: [PATCH 10/22] fix: decrease logging of quorum lists

---
 .../main/java/org/bitcoinj/evolution/QuorumRotationState.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/evolution/QuorumRotationState.java b/core/src/main/java/org/bitcoinj/evolution/QuorumRotationState.java
index 1c48e25c0d..bee949face 100644
--- a/core/src/main/java/org/bitcoinj/evolution/QuorumRotationState.java
+++ b/core/src/main/java/org/bitcoinj/evolution/QuorumRotationState.java
@@ -1075,7 +1075,7 @@ public SimplifiedMasternodeList getMnListAtH() {
 
     public SimplifiedQuorumList getQuorumListAtH() {
         SimplifiedQuorumList topList = getTopActiveQuorumList();
-        log.warn("obtaining this quorum list: {} from {} quorum lists", topList, activeQuorumLists.size());
+        log.debug("obtaining this quorum list: {} from {} quorum lists", topList, activeQuorumLists.size());
         return topList;
     }
 
@@ -1106,7 +1106,7 @@ public SimplifiedQuorumList getQuorumListForBlock(StoredBlock block) {
         if (topList.getHeight() == -1) {
             topList = getTopActiveQuorumList();
         }
-        log.warn("obtaining quorum list {}: {} from {} quorum lists", block.getHeight(), topList, activeQuorumLists.size());
+        log.debug("obtaining quorum list {}: {} from {} quorum lists", block.getHeight(), topList, activeQuorumLists.size());
         return topList;
     }
 

From bd2f7edd14619e1031964b0ee0aa152e4101d200 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:17:15 -0700
Subject: [PATCH 11/22] fix: improve InstantSend lock processing

---
 .../bitcoinj/quorums/InstantSendManager.java  | 66 ++++++++++++-------
 1 file changed, 41 insertions(+), 25 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
index e6444d519f..c34c003891 100644
--- a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
+++ b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
@@ -192,14 +192,15 @@ public void processInstantSendLock(Peer peer, InstantSendLock isLock) {
 
         Transaction walletTx = getWalletTransaction(isLock.txid);
         if (walletTx != null) {
-            context.getConfidenceTable().seen(isLock.txid, peer.getAddress());
             TransactionConfidence confidence = walletTx.getConfidence();
-            if (confidence.getIXType() != TransactionConfidence.IXType.IX_NONE) {
-                return;
+            // TODO: should we update the seen list?
+            // confidence.markBroadcastBy(peer.getAddress());
+            if (confidence.getIXType() == TransactionConfidence.IXType.IX_NONE) {
+                confidence.setIXType(TransactionConfidence.IXType.IX_REQUEST);
+                confidence.setInstantSendLock(isLock);
+                confidence.queueListeners(TransactionConfidence.Listener.ChangeReason.IX_TYPE);
             }
-            confidence.setIXType(TransactionConfidence.IXType.IX_REQUEST);
-            confidence.setInstantSendLock(isLock);
-            confidence.queueListeners(TransactionConfidence.Listener.ChangeReason.IX_TYPE);
+            // Fall through to queue for BLS verification regardless of prior IX state.
         }
 
         Sha256Hash hash = isLock.getHash();
@@ -681,8 +682,8 @@ HashSet<Sha256Hash> processPendingInstantSendLocks(LLMQParameters.LLMQType llmqT
         return badISLocks;
     }
 
-    void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
-    {
+    /** processes a verified instant send lock */
+    void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock) {
         StoredBlock minedBlock = null;
 
         TransactionConfidence confidence = context.getConfidenceTable().get(islock.txid);
@@ -713,6 +714,9 @@ void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
 
             InstantSendLock otherIsLock;
             if (db.getInstantSendLockByHash(hash) != null) {
+                // ISLock already verified and in DB. TX may have arrived late in the wallet
+                // (deferred case) — apply IX_LOCKED to it now if present.
+                updateWalletTransaction(islock.txid);
                 return;
             }
             otherIsLock = db.getInstantSendLockByTxid(islock.txid);
@@ -743,23 +747,21 @@ void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
         }
 
         removeMempoolConflictsForLock(hash, islock);
-        updateWalletTransaction(islock.txid, null);
+        updateWalletTransaction(islock.txid);
     }
 
-    void updateWalletTransaction(Sha256Hash txid, Transaction tx) {
-        Transaction walletTx = tx;
-        if (walletTx == null) {
-            walletTx = getWalletTransaction(txid);
-        }
-        if (walletTx == null) {
-            log.debug("ignoring ISLock for txid {} — not a wallet transaction", txid);
-            return;
+    /** apply Locked */
+    private void updateWalletTransaction(Sha256Hash txid) {
+        for (Wallet wallet : wallets) {
+            Transaction walletTx = wallet.getTransaction(txid);
+            if (walletTx != null) {
+                TransactionConfidence confidence = walletTx.getConfidence();
+                confidence.setIXType(TransactionConfidence.IXType.IX_LOCKED);
+                confidence.queueListeners(TransactionConfidence.Listener.ChangeReason.IX_TYPE);
+                return;
+            }
         }
-        TransactionConfidence confidence = walletTx.getConfidence();
-        scheduledExecutorService.schedule(() -> {
-            confidence.setIXType(TransactionConfidence.IXType.IX_LOCKED);
-            confidence.queueListeners(TransactionConfidence.Listener.ChangeReason.IX_TYPE);
-        }, 250, TimeUnit.MILLISECONDS);
+        log.debug("ignoring ISLock for txid {} — not a wallet transaction", txid);
     }
 
     @Nullable
@@ -813,9 +815,23 @@ public void syncTransaction(Transaction tx, StoredBlock block, int posInBlock) {
         }
 
         // If an ISLock was received before this transaction arrived in the wallet,
-        // apply it now that the transaction is known.
+        // re-queue it for processing so the verify path (processInstantSendLock) applies
+        // IX_LOCKED. This keeps IX_LOCKED assignment inside the single authoritative path.
         if (!isDisconnect && islockHash != null && !islockHash.isZero()) {
-            updateWalletTransaction(tx.getTxId(), tx);
+            InstantSendLock islock = db.getInstantSendLockByHash(islockHash);
+            if (islock != null && tx.getConfidence().getIXType() != TransactionConfidence.IXType.IX_LOCKED) {
+                lock.lock();
+                try {
+                    if (!pendingInstantSendLocks.containsKey(islockHash)) {
+                        pendingInstantSendLocks.put(islockHash, new Pair<>((long) -1, islock));
+                    }
+                } finally {
+                    lock.unlock();
+                }
+                if (runWithoutThread) {
+                    processPendingInstantSendLocks();
+                }
+            }
         }
     }
 
@@ -870,7 +886,7 @@ void handleFullyConfirmedBlock(int height)
         }
 
         for (Map.Entry<Sha256Hash, InstantSendLock> p : removeISLocks.entrySet()) {
-            updateWalletTransaction(p.getValue().txid, null);
+            updateWalletTransaction(p.getValue().txid);
         }
     }
     static final String INPUTLOCK_REQUESTID_PREFIX = "inlock";

From 57def7bd076730a067adc59f2b626db651ac7b9f Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:17:56 -0700
Subject: [PATCH 12/22] tests: fix CoinJoinSessionTest intermittent failures

---
 .../java/org/bitcoinj/coinjoin/CoinJoinSessionTest.java     | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/core/src/test/java/org/bitcoinj/coinjoin/CoinJoinSessionTest.java b/core/src/test/java/org/bitcoinj/coinjoin/CoinJoinSessionTest.java
index 7514d23dc0..a6a1baae4d 100644
--- a/core/src/test/java/org/bitcoinj/coinjoin/CoinJoinSessionTest.java
+++ b/core/src/test/java/org/bitcoinj/coinjoin/CoinJoinSessionTest.java
@@ -428,6 +428,12 @@ public void sessionTestTwo() throws Exception {
             system.coinJoinManager.doMaintenance();
             addBlock();
         } while (lastMasternode == null);
+
+        // processPendingDsaRequest() is called before doAutomaticDenominating() in doMaintenance(),
+        // so the pendingDsaRequest set during the last iteration hasn't been sent yet. Run one more
+        // maintenance pass to send the CoinJoinAccept to the masternode.
+        system.coinJoinManager.doMaintenance();
+
         assertEquals(Coin.FIFTY_COINS, wallet.getBalance(Wallet.BalanceType.AVAILABLE_SPENDABLE));
         Coin initialDenominatedBalance = Coin.valueOf(102101021);
         assertEquals(initialDenominatedBalance, mixingWallet.getBalanceInfo().getDenominatedTrusted());

From 2c12ef52bfdfd62757ba0eacd2afc4101b1f0f94 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:18:38 -0700
Subject: [PATCH 13/22] feat: ad CoinJoinForwardingService example that
 simulates a large coinjoin wallet

---
 .../examples/CoinJoinForwardingService.java   | 299 ++++++++++++++++++
 1 file changed, 299 insertions(+)
 create mode 100644 examples/src/main/java/org/bitcoinj/examples/CoinJoinForwardingService.java

diff --git a/examples/src/main/java/org/bitcoinj/examples/CoinJoinForwardingService.java b/examples/src/main/java/org/bitcoinj/examples/CoinJoinForwardingService.java
new file mode 100644
index 0000000000..8663f7b9d9
--- /dev/null
+++ b/examples/src/main/java/org/bitcoinj/examples/CoinJoinForwardingService.java
@@ -0,0 +1,299 @@
+/*
+ * Copyright 2013 Google Inc.
+ * Copyright 2014 Andreas Schildbach
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.bitcoinj.examples;
+
+import org.bitcoinj.core.*;
+import org.bitcoinj.core.listeners.NewBestBlockListener;
+import org.bitcoinj.crypto.KeyCrypterException;
+import org.bitcoinj.examples.debug.BlockReport;
+import org.bitcoinj.examples.debug.TransactionReport;
+import org.bitcoinj.kits.WalletAppKit;
+import org.bitcoinj.net.discovery.ThreeMethodPeerDiscovery;
+import org.bitcoinj.params.*;
+import org.bitcoinj.quorums.listeners.ChainLockListener;
+import org.bitcoinj.script.Script;
+import org.bitcoinj.script.ScriptBuilder;
+import org.bitcoinj.utils.BriefLogFormatter;
+import org.bitcoinj.wallet.DeterministicSeed;
+import org.bitcoinj.wallet.KeyChainGroup;
+import org.bitcoinj.wallet.Protos;
+import org.bitcoinj.wallet.SendRequest;
+import org.bitcoinj.wallet.Wallet;
+import org.bitcoinj.wallet.WalletEx;
+import org.bitcoinj.wallet.listeners.WalletCoinsReceivedEventListener;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.MoreExecutors;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.nio.charset.StandardCharsets;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * CoinJoinForwardingService demonstrates usage of the library with the CoinJoinExtension.
+ * It sits on the network and when it receives coins, simply sends them onwards to an address
+ * given on the command line. The wallet maintains 30,000 CoinJoin addresses.
+ */
+public class CoinJoinForwardingService {
+    private static final int COINJOIN_KEY_COUNT = 3000;
+
+    private static Address forwardingAddress;
+    private static WalletAppKit kit;
+
+    private static TransactionReport txReport;
+    private static BlockReport blockReport;
+
+    public static void main(String[] args) throws Exception {
+        // This line makes the log output more compact and easily read, especially when using the JDK log adapter.
+        BriefLogFormatter.init();
+        if (args.length < 1) {
+            System.err.println("Usage: address-to-send-back-to [regtest|testnet|333|devnet] [devnet-name] [devnet-sporkaddress] [devnet-port] [devnet-dnsseed...]");
+            return;
+        }
+
+        // Figure out which network we should connect to. Each one gets its own set of files.
+        NetworkParameters params;
+        String filePrefix;
+        String checkpoints = null;
+        int lastArg = 2;
+        if (args.length > 1 && args[1].equals("testnet")) {
+            params = TestNet3Params.get();
+            filePrefix = "coinjoin-forwarding-service-testnet";
+            checkpoints = "checkpoints-testnet.txt";
+        } else if (args.length > 1 && args[1].equals("regtest")) {
+            params = RegTestParams.get();
+            filePrefix = "coinjoin-forwarding-service-regtest";
+        } else if (args.length > 1 && args[1].equals("white-russian")) {
+            params = WhiteRussianDevNetParams.get();
+            filePrefix = "coinjoin-forwarding-service-white-russian";
+        } else if (args.length > 1 && args[1].equals("ouzo")) {
+            params = OuzoDevNetParams.get();
+            filePrefix = "coinjoin-forwarding-service-ouzo";
+        } else if (args.length > 6 && args[1].equals("devnet")) {
+            String[] dnsSeeds = new String[args.length - 5];
+            System.arraycopy(args, 5, dnsSeeds, 0, args.length - 5);
+            params = DevNetParams.get(args[2], args[3], Integer.parseInt(args[4]), dnsSeeds);
+            filePrefix = "coinjoin-forwarding-service-devnet";
+        } else {
+            lastArg = 1;
+            params = MainNetParams.get();
+            filePrefix = "coinjoin-forwarding-service";
+            checkpoints = "checkpoints.txt";
+        }
+
+        String clientPath = "";
+        String confPath = "";
+        if (lastArg + 1 < args.length) {
+            clientPath = args[lastArg];
+            if (lastArg + 2 > args.length)
+                confPath = args[lastArg];
+        }
+
+        txReport = new TransactionReport(clientPath, confPath, params);
+        blockReport = new BlockReport(clientPath, confPath, params);
+        // Parse the address given as the first parameter.
+        forwardingAddress = Address.fromBase58(params, args[0]);
+
+        System.out.println("Network: " + params.getId());
+        System.out.println("Forwarding address: " + forwardingAddress);
+
+        // Use WalletEx as the wallet type so the CoinJoinExtension is included automatically.
+        final NetworkParameters finalParams = params;
+        kit = new WalletAppKit(params, new File("."), filePrefix) {
+            @Override
+            protected void onSetupCompleted() {
+                kit.peerGroup().setMaxConnections(6); // for small devnets
+                kit.peerGroup().setUseLocalhostPeerWhenPossible(false);
+                kit.peerGroup().setDropPeersAfterBroadcast(finalParams.getDropPeersAfterBroadcast());
+                kit.wallet().getContext().setDebugMode(false);
+                kit.setDiscovery(new ThreeMethodPeerDiscovery(finalParams, kit.system().masternodeListManager));
+
+                // Initialize CoinJoin key chain and issue keys up to COINJOIN_KEY_COUNT
+                WalletEx walletEx = (WalletEx) kit.wallet();
+                if (!walletEx.getCoinJoin().hasKeyChain(
+                        org.bitcoinj.wallet.DerivationPathFactory.get(finalParams).coinJoinDerivationPath(0))) {
+                    walletEx.initializeCoinJoin(0);
+                }
+                int issuedCount = walletEx.getCoinJoin().getKeyChainGroup()
+                        .getActiveKeyChain().getIssuedReceiveKeys().size();
+                int keysToIssue = COINJOIN_KEY_COUNT - issuedCount;
+                if (keysToIssue > 0) {
+                    System.out.println("Issuing " + keysToIssue + " CoinJoin keys (already have " + issuedCount + ")...");
+                    for (int i = 0; i < keysToIssue; i++) {
+                        walletEx.getCoinJoin().freshReceiveKey();
+                    }
+                    System.out.println("CoinJoin keys ready: " + COINJOIN_KEY_COUNT);
+                } else {
+                    System.out.println("CoinJoin keys already at target: " + issuedCount);
+                }
+            }
+
+            @Override
+            protected Wallet createWallet() {
+                return new WalletEx(finalParams,
+                        KeyChainGroup.builder(finalParams, structure)
+                                .fromRandom(Script.ScriptType.P2PKH)
+                                .build()
+                );
+            }
+        };
+
+        // Tell WalletAppKit to use WalletEx when loading an existing wallet file too.
+        kit.setWalletFactory((p, kcg) -> new WalletEx(p, kcg));
+
+        if (params == RegTestParams.get()) {
+            kit.connectToLocalHost();
+        }
+
+        if (checkpoints != null) {
+            try {
+                FileInputStream checkpointStream = new FileInputStream("./" + checkpoints);
+                kit.setCheckpoints(checkpointStream);
+            } catch (FileNotFoundException x) {
+                //swallow
+            }
+        }
+
+        // Download the block chain and wait until it's done.
+        kit.startAsync();
+        kit.awaitRunning();
+
+        // We want to know when we receive money.
+        kit.wallet().addCoinsReceivedEventListener(new WalletCoinsReceivedEventListener() {
+            @Override
+            public void onCoinsReceived(Wallet w, Transaction tx, Coin prevBalance, Coin newBalance) {
+                Coin value = tx.getValueSentToMe(w);
+                System.out.println("Received tx for " + value.toFriendlyString() + ": " + tx);
+                System.out.println("Transaction will be forwarded after it confirms.");
+
+                txReport.add(System.currentTimeMillis(), w.getLastBlockSeenHeight(), tx);
+                tx.getConfidence().addEventListener(confidenceListener);
+                Futures.addCallback(tx.getConfidence().getDepthFuture(1), new FutureCallback<TransactionConfidence>() {
+                    @Override
+                    public void onSuccess(TransactionConfidence result) {
+                        Context.propagate(kit.wallet().getContext());
+                        System.out.println("Confirmation received.");
+                        forwardCoins(tx);
+
+                        txReport.printReport();
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        throw new RuntimeException(t);
+                    }
+                }, MoreExecutors.directExecutor());
+            }
+        });
+
+        kit.chain().addNewBestBlockListener(new NewBestBlockListener() {
+            @Override
+            public void notifyNewBestBlock(StoredBlock block) throws VerificationException {
+                blockReport.add(block);
+                blockReport.printReport();
+            }
+        });
+        kit.system().chainLockHandler.addChainLockListener(new ChainLockListener() {
+            @Override
+            public void onNewChainLock(StoredBlock block) {
+                blockReport.setChainLock(block);
+            }
+        });
+
+        Address sendToAddress = Address.fromKey(params, kit.wallet().currentReceiveKey());
+        System.out.println("Send coins to: " + sendToAddress);
+        System.out.println("Waiting for coins to arrive. Press Ctrl-C to quit.");
+
+        try {
+            Thread.sleep(Long.MAX_VALUE);
+        } catch (InterruptedException ignored) {}
+    }
+
+    private static void forwardCoins(Transaction tx) {
+        try {
+            Wallet wallet = kit.wallet();
+            if (wallet.getBalance().equals(Coin.ZERO)) {
+                return;
+            }
+
+            Coin valueReceived = tx.getValueSentToMe(wallet);
+            Coin tenPercent = valueReceived.divide(10);
+            Coin dustThreshold = Coin.valueOf(542);
+
+            Address senderAddress = getSenderAddress(tx, wallet.getNetworkParameters());
+
+            SendRequest sendRequest;
+            if (senderAddress != null && !tenPercent.isLessThan(dustThreshold)) {
+                Transaction forwardTx = new Transaction(wallet.getNetworkParameters());
+                forwardTx.addOutput(tenPercent, senderAddress);
+                sendRequest = SendRequest.forTx(forwardTx);
+                sendRequest.changeAddress = forwardingAddress;
+                sendRequest.tx.addOutput(Coin.ZERO, ScriptBuilder.createOpReturnScript("test message".getBytes(StandardCharsets.UTF_8)));
+                System.out.println("Sending 10% (" + tenPercent.toFriendlyString() + ") back to " + senderAddress);
+            } else {
+                sendRequest = SendRequest.emptyWallet(forwardingAddress);
+            }
+
+            Wallet.SendResult sendResult = wallet.sendCoins(sendRequest);
+            checkNotNull(sendResult);
+            System.out.println("Sending ...");
+            sendResult.broadcastComplete.addListener(new Runnable() {
+                @Override
+                public void run() {
+                    System.out.println("Sent coins onwards! Transaction hash is " + sendResult.tx.getTxId());
+                    wallet.getTransaction(sendResult.tx.getTxId()).getConfidence().addEventListener(confidenceListener);
+                }
+            }, MoreExecutors.directExecutor());
+
+        } catch (KeyCrypterException | InsufficientMoneyException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static Address getSenderAddress(Transaction tx, NetworkParameters params) {
+        for (TransactionInput input : tx.getInputs()) {
+            try {
+                Script scriptSig = input.getScriptSig();
+                if (scriptSig.getChunks().size() == 2) {
+                    byte[] pubKeyBytes = scriptSig.getChunks().get(1).data;
+                    if (pubKeyBytes != null && (pubKeyBytes.length == 33 || pubKeyBytes.length == 65)) {
+                        ECKey key = ECKey.fromPublicOnly(pubKeyBytes);
+                        return Address.fromKey(params, key, Script.ScriptType.P2PKH);
+                    }
+                }
+            } catch (Exception e) {
+                // skip this input, try the next
+            }
+        }
+        return null;
+    }
+
+    static TransactionConfidence.Listener confidenceListener = new TransactionConfidence.Listener() {
+        @Override
+        public void onConfidenceChanged(TransactionConfidence confidence, ChangeReason reason) {
+            System.out.println(" confidence change: " + confidence.getTransactionHash() + ": " + reason);
+            if (confidence.getDepthInBlocks() > 6) {
+                confidence.removeEventListener(confidenceListener);
+            }
+        }
+    };
+}
\ No newline at end of file

From 816c9e8078e3a1cd01694d7f98d695ceb52403b4 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:39:59 -0700
Subject: [PATCH 14/22] fix: more InstantSendManager improvements

---
 .../bitcoinj/quorums/InstantSendManager.java  | 38 ++++++++++---------
 1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
index c34c003891..15e16f5172 100644
--- a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
+++ b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
@@ -219,19 +219,19 @@ public void processInstantSendLock(Peer peer, InstantSendLock isLock) {
                     isLock.txid, hash, peer.hashCode());
 
             pendingInstantSendLocks.put(hash, new Pair<>((long)peer.hashCode(), isLock));
+        } finally {
+            lock.unlock();
+        }
 
-            if (runWithoutThread) {
-                try {
-                    processPendingInstantSendLocks();
-                } catch (RuntimeException x) {
-                    if (x.getCause() instanceof BlockStoreException) {
-                        throw new VerificationException(x.getCause().getMessage());
-                    }
-                    throw x;
+        if (runWithoutThread) {
+            try {
+                processPendingInstantSendLocks();
+            } catch (RuntimeException x) {
+                if (x.getCause() instanceof BlockStoreException) {
+                    throw new VerificationException(x.getCause().getMessage());
                 }
+                throw x;
             }
-        } finally {
-            lock.unlock();
         }
     }
 
@@ -716,7 +716,7 @@ void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
             if (db.getInstantSendLockByHash(hash) != null) {
                 // ISLock already verified and in DB. TX may have arrived late in the wallet
                 // (deferred case) — apply IX_LOCKED to it now if present.
-                updateWalletTransaction(islock.txid);
+                updateWalletTransaction(islock.txid, islock);
                 return;
             }
             otherIsLock = db.getInstantSendLockByTxid(islock.txid);
@@ -747,21 +747,25 @@ void processInstantSendLock(long from, Sha256Hash hash, InstantSendLock islock)
         }
 
         removeMempoolConflictsForLock(hash, islock);
-        updateWalletTransaction(islock.txid);
+        updateWalletTransaction(islock.txid, islock);
     }
 
-    /** apply Locked */
-    private void updateWalletTransaction(Sha256Hash txid) {
+    /** apply Locked and attach the ISLock to confidence for every matching wallet */
+    private void updateWalletTransaction(Sha256Hash txid, InstantSendLock islock) {
+        boolean found = false;
         for (Wallet wallet : wallets) {
             Transaction walletTx = wallet.getTransaction(txid);
             if (walletTx != null) {
                 TransactionConfidence confidence = walletTx.getConfidence();
+                confidence.setInstantSendLock(islock);
                 confidence.setIXType(TransactionConfidence.IXType.IX_LOCKED);
                 confidence.queueListeners(TransactionConfidence.Listener.ChangeReason.IX_TYPE);
-                return;
+                found = true;
             }
         }
-        log.debug("ignoring ISLock for txid {} — not a wallet transaction", txid);
+        if (!found) {
+            log.debug("ignoring ISLock for txid {} — not a wallet transaction", txid);
+        }
     }
 
     @Nullable
@@ -886,7 +890,7 @@ void handleFullyConfirmedBlock(int height)
         }
 
         for (Map.Entry<Sha256Hash, InstantSendLock> p : removeISLocks.entrySet()) {
-            updateWalletTransaction(p.getValue().txid);
+            updateWalletTransaction(p.getValue().txid, p.getValue());
         }
     }
     static final String INPUTLOCK_REQUESTID_PREFIX = "inlock";

From 28570f73d58ded75dfd78410b360dc0b88f286d8 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:52:13 -0700
Subject: [PATCH 15/22] fix: improve CoinJoinForwardingService

---
 .../org/bitcoinj/examples/CoinJoinForwardingService.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/examples/src/main/java/org/bitcoinj/examples/CoinJoinForwardingService.java b/examples/src/main/java/org/bitcoinj/examples/CoinJoinForwardingService.java
index 8663f7b9d9..e96fcd2c8b 100644
--- a/examples/src/main/java/org/bitcoinj/examples/CoinJoinForwardingService.java
+++ b/examples/src/main/java/org/bitcoinj/examples/CoinJoinForwardingService.java
@@ -102,10 +102,11 @@ public static void main(String[] args) throws Exception {
 
         String clientPath = "";
         String confPath = "";
-        if (lastArg + 1 < args.length) {
+        if (lastArg < args.length) {
             clientPath = args[lastArg];
-            if (lastArg + 2 > args.length)
-                confPath = args[lastArg];
+        }
+        if (lastArg + 1 < args.length) {
+            confPath = args[lastArg + 1];
         }
 
         txReport = new TransactionReport(clientPath, confPath, params);
@@ -169,7 +170,7 @@ protected Wallet createWallet() {
                 FileInputStream checkpointStream = new FileInputStream("./" + checkpoints);
                 kit.setCheckpoints(checkpointStream);
             } catch (FileNotFoundException x) {
-                //swallow
+                System.err.println("Checkpoint file not found: " + checkpoints + " (continuing without checkpoints)");
             }
         }
 

From 2939dfbc29571cf8244215ac5a69ff556cfeda24 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Fri, 27 Mar 2026 11:52:26 -0700
Subject: [PATCH 16/22] fix: improve WalletProtobufSerializer.readWallet

---
 .../wallet/WalletProtobufSerializer.java      | 602 +++++++++---------
 1 file changed, 307 insertions(+), 295 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
index 4d1d0928d1..04038e8754 100644
--- a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
+++ b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
@@ -110,6 +110,7 @@ public interface WalletFactory {
 
     private final WalletFactory factory;
     private KeyChainFactory keyChainFactory;
+    private final Object factoryLock = new Object();
     private volatile boolean lastSaveParallel = false;
 
     public WalletProtobufSerializer() {
@@ -128,7 +129,9 @@ public WalletProtobufSerializer(WalletFactory factory) {
     }
 
     public void setKeyChainFactory(KeyChainFactory keyChainFactory) {
-        this.keyChainFactory = keyChainFactory;
+        synchronized (factoryLock) {
+            this.keyChainFactory = keyChainFactory;
+        }
     }
 
     /**
@@ -925,236 +928,352 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
         if (!walletProto.getNetworkIdentifier().equals(params.getId()))
             throw new UnreadableWalletException.WrongNetwork();
 
+        // Snapshot the factory once under the lock so concurrent setKeyChainFactory calls
+        // cannot affect an in-flight parse (especially important for the parallel path).
+        final KeyChainFactory effectiveFactory;
+        synchronized (factoryLock) {
+            effectiveFactory = this.keyChainFactory;
+        }
+
         long methodStart = System.currentTimeMillis();
         int complexityScore = getProtoComplexityScore(walletProto);
         boolean isLargeWallet = parallelLoad && complexityScore > 10_000;
 
-        if (isLargeWallet) {
-            final long[] keysTime = {0}, friendRecvTime = {0}, friendSendTime = {0}, txTime = {0}, addWalletTime = {0};
-            final boolean hasEncryption = walletProto.hasEncryptionParameters();
-            final KeyCrypterScrypt keyCrypter = hasEncryption ?
-                    new KeyCrypterScrypt(walletProto.getEncryptionParameters()) : null;
-
-            int numThreads = Math.min(Runtime.getRuntime().availableProcessors(), 8);
-            // +3 extra threads so keys/friendRecv/friendSend don't compete with tx batch threads
-            ExecutorService executor = Executors.newFixedThreadPool(numThreads + 3,
-                    new ContextPropagatingThreadFactory("wallet-deserializer"));
-            try {
-                // Future 1: Parse key chain group (most expensive)
-                CompletableFuture<KeyChainGroup> keysFuture = CompletableFuture.supplyAsync(() -> {
-                    log.info("readWallet: keys thread started ({} keys)", walletProto.getKeyCount());
-                    long start = System.currentTimeMillis();
-                    try {
-                        KeyChainGroup kcg = hasEncryption ?
-                                KeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeyList(), keyCrypter, keyChainFactory) :
-                                KeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeyList(), keyChainFactory);
-                        keysTime[0] = System.currentTimeMillis() - start;
-                        log.info("readWallet: keys thread done in {}ms", keysTime[0]);
-                        return kcg;
-                    } catch (UnreadableWalletException e) {
-                        throw new RuntimeException(e);
-                    }
-                }, executor);
-
-                // Future 2: Parse receiving friend key chains (if present)
-                CompletableFuture<FriendKeyChainGroup> friendRecvFuture = null;
-                if (walletProto.getKeysForFriendsCount() > 0) {
-                    friendRecvFuture = CompletableFuture.supplyAsync(() -> {
-                        log.info("readWallet: friendRecv thread started ({} keys)", walletProto.getKeysForFriendsCount());
+        try {
+            if (isLargeWallet) {
+                final long[] keysTime = {0}, friendRecvTime = {0}, friendSendTime = {0}, txTime = {0}, addWalletTime = {0};
+                final boolean hasEncryption = walletProto.hasEncryptionParameters();
+                final KeyCrypterScrypt keyCrypter = hasEncryption ?
+                        new KeyCrypterScrypt(walletProto.getEncryptionParameters()) : null;
+
+                int numThreads = Math.min(Runtime.getRuntime().availableProcessors(), 8);
+                // +3 extra threads so keys/friendRecv/friendSend don't compete with tx batch threads
+                ExecutorService executor = Executors.newFixedThreadPool(numThreads + 3,
+                        new ContextPropagatingThreadFactory("wallet-deserializer"));
+                try {
+                    // Future 1: Parse key chain group (most expensive)
+                    CompletableFuture<KeyChainGroup> keysFuture = CompletableFuture.supplyAsync(() -> {
+                        log.info("readWallet: keys thread started ({} keys)", walletProto.getKeyCount());
                         long start = System.currentTimeMillis();
                         try {
-                            FriendKeyChainGroup fkcg = hasEncryption ?
-                                    FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysForFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN) :
-                                    FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysForFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
-                            friendRecvTime[0] = System.currentTimeMillis() - start;
-                            log.info("readWallet: friendRecv thread done in {}ms", friendRecvTime[0]);
-                            return fkcg;
+                            KeyChainGroup kcg = hasEncryption ?
+                                    KeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeyList(), keyCrypter, effectiveFactory) :
+                                    KeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeyList(), effectiveFactory);
+                            keysTime[0] = System.currentTimeMillis() - start;
+                            log.info("readWallet: keys thread done in {}ms", keysTime[0]);
+                            return kcg;
                         } catch (UnreadableWalletException e) {
                             throw new RuntimeException(e);
                         }
                     }, executor);
-                }
 
-                // Future 3: Parse sending friend key chains (if present)
-                CompletableFuture<FriendKeyChainGroup> friendSendFuture = null;
-                if (walletProto.getKeysFromFriendsCount() > 0) {
-                    friendSendFuture = CompletableFuture.supplyAsync(() -> {
-                        log.info("readWallet: friendSend thread started ({} keys)", walletProto.getKeysFromFriendsCount());
-                        long start = System.currentTimeMillis();
-                        try {
-                            FriendKeyChainGroup fkcg = hasEncryption ?
-                                    FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysFromFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN) :
-                                    FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysFromFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
-                            friendSendTime[0] = System.currentTimeMillis() - start;
-                            log.info("readWallet: friendSend thread done in {}ms", friendSendTime[0]);
-                            return fkcg;
-                        } catch (UnreadableWalletException e) {
-                            throw new RuntimeException(e);
-                        }
-                    }, executor);
-                }
+                    // Future 2: Parse receiving friend key chains (if present)
+                    CompletableFuture<FriendKeyChainGroup> friendRecvFuture = null;
+                    if (walletProto.getKeysForFriendsCount() > 0) {
+                        friendRecvFuture = CompletableFuture.supplyAsync(() -> {
+                            log.info("readWallet: friendRecv thread started ({} keys)", walletProto.getKeysForFriendsCount());
+                            long start = System.currentTimeMillis();
+                            try {
+                                FriendKeyChainGroup fkcg = hasEncryption ?
+                                        FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysForFriendsList(), keyCrypter, effectiveFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN) :
+                                        FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysForFriendsList(), effectiveFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
+                                friendRecvTime[0] = System.currentTimeMillis() - start;
+                                log.info("readWallet: friendRecv thread done in {}ms", friendRecvTime[0]);
+                                return fkcg;
+                            } catch (UnreadableWalletException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }, executor);
+                    }
 
-                // Parse transactions in batches (one future per thread) to avoid per-tx future overhead
-                Map<ByteString, Transaction> parsedTxs = new ConcurrentHashMap<>();
-                List<CompletableFuture<Void>> txFutures = new ArrayList<>();
-                long txFuturesStart = System.currentTimeMillis();
-                if (!forceReset) {
-                    List<Protos.Transaction> allTxProtos = walletProto.getTransactionList();
-                    // Use total pool size as batch count so freed key/friend threads can pick up tx work
-                    int txBatchCount = numThreads + 3;
-                    int txBatchSize = Math.max(1, (allTxProtos.size() + txBatchCount - 1) / txBatchCount);
-                    log.info("readWallet: tx threads starting ({} transactions, batchCount={}, batchSize={})",
-                            allTxProtos.size(), txBatchCount, txBatchSize);
-                    for (int i = 0; i < allTxProtos.size(); i += txBatchSize) {
-                        final int from = i;
-                        final int to = Math.min(i + txBatchSize, allTxProtos.size());
-                        txFutures.add(CompletableFuture.runAsync(() -> {
-                            for (int j = from; j < to; j++) {
-                                Protos.Transaction txProto = allTxProtos.get(j);
-                                try {
-                                    Transaction tx = parseTransactionFromProto(txProto, params);
-                                    if (parsedTxs.putIfAbsent(txProto.getHash(), tx) != null)
-                                        throw new RuntimeException(new UnreadableWalletException(
-                                                "Wallet contained duplicate transaction " + byteStringToHash(txProto.getHash())));
-                                } catch (UnreadableWalletException e) {
-                                    throw new RuntimeException(e);
-                                }
+                    // Future 3: Parse sending friend key chains (if present)
+                    CompletableFuture<FriendKeyChainGroup> friendSendFuture = null;
+                    if (walletProto.getKeysFromFriendsCount() > 0) {
+                        friendSendFuture = CompletableFuture.supplyAsync(() -> {
+                            log.info("readWallet: friendSend thread started ({} keys)", walletProto.getKeysFromFriendsCount());
+                            long start = System.currentTimeMillis();
+                            try {
+                                FriendKeyChainGroup fkcg = hasEncryption ?
+                                        FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysFromFriendsList(), keyCrypter, effectiveFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN) :
+                                        FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysFromFriendsList(), effectiveFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
+                                friendSendTime[0] = System.currentTimeMillis() - start;
+                                log.info("readWallet: friendSend thread done in {}ms", friendSendTime[0]);
+                                return fkcg;
+                            } catch (UnreadableWalletException e) {
+                                throw new RuntimeException(e);
                             }
-                        }, executor));
+                        }, executor);
                     }
-                }
 
-                // While parallel tasks run, parse the quick sequential parts
-                List<Script> scripts = new ArrayList<>();
-                for (Protos.Script protoScript : walletProto.getWatchedScriptList()) {
-                    try {
-                        scripts.add(new Script(protoScript.getProgram().toByteArray(),
-                                protoScript.getCreationTimestamp() / 1000));
-                    } catch (ScriptException e) {
-                        throw new UnreadableWalletException("Unparseable script in wallet");
+                    // Parse transactions in batches (one future per thread) to avoid per-tx future overhead
+                    Map<ByteString, Transaction> parsedTxs = new ConcurrentHashMap<>();
+                    List<CompletableFuture<Void>> txFutures = new ArrayList<>();
+                    long txFuturesStart = System.currentTimeMillis();
+                    if (!forceReset) {
+                        List<Protos.Transaction> allTxProtos = walletProto.getTransactionList();
+                        // Use total pool size as batch count so freed key/friend threads can pick up tx work
+                        int txBatchCount = numThreads + 3;
+                        int txBatchSize = Math.max(1, (allTxProtos.size() + txBatchCount - 1) / txBatchCount);
+                        log.info("readWallet: tx threads starting ({} transactions, batchCount={}, batchSize={})",
+                                allTxProtos.size(), txBatchCount, txBatchSize);
+                        for (int i = 0; i < allTxProtos.size(); i += txBatchSize) {
+                            final int from = i;
+                            final int to = Math.min(i + txBatchSize, allTxProtos.size());
+                            txFutures.add(CompletableFuture.runAsync(() -> {
+                                for (int j = from; j < to; j++) {
+                                    Protos.Transaction txProto = allTxProtos.get(j);
+                                    try {
+                                        Transaction tx = parseTransactionFromProto(txProto, params);
+                                        if (parsedTxs.putIfAbsent(txProto.getHash(), tx) != null)
+                                            throw new RuntimeException(new UnreadableWalletException(
+                                                    "Wallet contained duplicate transaction " + byteStringToHash(txProto.getHash())));
+                                    } catch (UnreadableWalletException e) {
+                                        throw new RuntimeException(e);
+                                    }
+                                }
+                            }, executor));
+                        }
                     }
-                }
 
-                // Retrieve key chain group and create wallet (blocks on keysFuture)
-                KeyChainGroup keyChainGroup;
-                try {
-                    keyChainGroup = keysFuture.get();
-                } catch (ExecutionException e) {
-                    Throwable cause = e.getCause();
-                    if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
-                    throw new UnreadableWalletException("Failed to parse key chain group", e);
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                    throw new UnreadableWalletException("Interrupted while parsing key chain group");
-                }
-                Wallet wallet = factory.create(params, keyChainGroup);
+                    // While parallel tasks run, parse the quick sequential parts
+                    List<Script> scripts = new ArrayList<>();
+                    for (Protos.Script protoScript : walletProto.getWatchedScriptList()) {
+                        try {
+                            scripts.add(new Script(protoScript.getProgram().toByteArray(),
+                                    protoScript.getCreationTimestamp() / 1000));
+                        } catch (ScriptException e) {
+                            throw new UnreadableWalletException("Unparseable script in wallet");
+                        }
+                    }
 
-                if (friendRecvFuture != null) {
+                    // Retrieve key chain group and create wallet (blocks on keysFuture)
+                    KeyChainGroup keyChainGroup;
                     try {
-                        wallet.setReceivingFromFriendsGroup(friendRecvFuture.get());
+                        keyChainGroup = keysFuture.get();
                     } catch (ExecutionException e) {
                         Throwable cause = e.getCause();
                         if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
-                        throw new UnreadableWalletException("Failed to parse receiving friend keys", e);
+                        throw new UnreadableWalletException("Failed to parse key chain group", e);
                     } catch (InterruptedException e) {
                         Thread.currentThread().interrupt();
-                        throw new UnreadableWalletException("Interrupted while parsing receiving friend keys");
+                        throw new UnreadableWalletException("Interrupted while parsing key chain group");
+                    }
+                    Wallet wallet = factory.create(params, keyChainGroup);
+
+                    if (friendRecvFuture != null) {
+                        try {
+                            wallet.setReceivingFromFriendsGroup(friendRecvFuture.get());
+                        } catch (ExecutionException e) {
+                            Throwable cause = e.getCause();
+                            if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                            throw new UnreadableWalletException("Failed to parse receiving friend keys", e);
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                            throw new UnreadableWalletException("Interrupted while parsing receiving friend keys");
+                        }
+                    }
+
+                    if (friendSendFuture != null) {
+                        try {
+                            wallet.setSendingToFriendsGroup(friendSendFuture.get());
+                        } catch (ExecutionException e) {
+                            Throwable cause = e.getCause();
+                            if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                            throw new UnreadableWalletException("Failed to parse sending friend keys", e);
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                            throw new UnreadableWalletException("Interrupted while parsing sending friend keys");
+                        }
+                    }
+
+                    wallet.addWatchedScripts(scripts);
+                    if (walletProto.hasDescription()) {
+                        wallet.setDescription(walletProto.getDescription());
+                    }
+
+                    // load extensions before processing transactions
+                    long extStart = System.currentTimeMillis();
+                    loadExtensions(wallet, extensions != null ? extensions : new WalletExtension[0], walletProto);
+                    long extTime = System.currentTimeMillis() - extStart;
+                    log.info("readWallet: loadExtensions done in {}ms", extTime);
+
+                    long connectTime = 0;
+                    if (forceReset) {
+                        wallet.setLastBlockSeenHash(null);
+                        wallet.setLastBlockSeenHeight(-1);
+                        wallet.setLastBlockSeenTimeSecs(0);
+                    } else {
+                        // Wait for all transaction futures, then populate txMap
+                        if (!txFutures.isEmpty()) {
+                            try {
+                                CompletableFuture.allOf(txFutures.toArray(new CompletableFuture[0])).get();
+                            } catch (ExecutionException e) {
+                                Throwable cause = e.getCause();
+                                if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
+                                    throw (UnreadableWalletException) cause.getCause();
+                                if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                                throw new UnreadableWalletException("Failed to parse transactions", e);
+                            } catch (InterruptedException e) {
+                                Thread.currentThread().interrupt();
+                                throw new UnreadableWalletException("Interrupted while parsing transactions");
+                            }
+                        }
+                        txTime[0] = System.currentTimeMillis() - txFuturesStart;
+                        log.info("readWallet: tx threads done in {}ms ({} transactions)", txTime[0], parsedTxs.size());
+                        txMap.putAll(parsedTxs);
+
+                        // Connect outputs in parallel: txMap is fully populated and read-only here.
+                        // Each call only touches its own tx's outputs and unique inputs of spending txs,
+                        // so concurrent calls do not write to the same fields.
+                        long connectStart = System.currentTimeMillis();
+                        List<Protos.Transaction> txProtoList = walletProto.getTransactionList();
+                        final WalletTransaction[] walletTxns = new WalletTransaction[txProtoList.size()];
+                        int connectBatchSize = Math.max(1, (txProtoList.size() + numThreads + 2) / (numThreads + 3));
+                        List<CompletableFuture<Void>> connectFutures = new ArrayList<>(numThreads);
+                        for (int i = 0; i < txProtoList.size(); i += connectBatchSize) {
+                            final int from = i;
+                            final int to = Math.min(i + connectBatchSize, txProtoList.size());
+                            connectFutures.add(CompletableFuture.runAsync(() -> {
+                                for (int j = from; j < to; j++) {
+                                    try {
+                                        walletTxns[j] = connectTransactionOutputs(params, txProtoList.get(j));
+                                    } catch (UnreadableWalletException e) {
+                                        throw new RuntimeException(e);
+                                    }
+                                }
+                            }, executor));
+                        }
+                        try {
+                            CompletableFuture.allOf(connectFutures.toArray(new CompletableFuture[0])).get();
+                        } catch (ExecutionException e) {
+                            Throwable cause = e.getCause();
+                            if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
+                                throw (UnreadableWalletException) cause.getCause();
+                            if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                            throw new UnreadableWalletException("Failed to connect transaction outputs", e);
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                            throw new UnreadableWalletException("Interrupted while connecting transaction outputs");
+                        }
+                        connectTime = System.currentTimeMillis() - connectStart;
+                        log.info("readWallet: connectOutputs done in {}ms (parallel)", connectTime);
+
+                        // Add to wallet sequentially (addWalletTransaction acquires write lock per call)
+                        long addWalletStart = System.currentTimeMillis();
+                        for (WalletTransaction wtx : walletTxns) {
+                            wallet.addWalletTransaction(wtx);
+                        }
+                        addWalletTime[0] = System.currentTimeMillis() - addWalletStart;
+                        log.info("readWallet: addWalletTransactions done in {}ms ({} txs)", addWalletTime[0], walletTxns.length);
+
+                        if (!walletProto.hasLastSeenBlockHash()) {
+                            wallet.setLastBlockSeenHash(null);
+                        } else {
+                            wallet.setLastBlockSeenHash(byteStringToHash(walletProto.getLastSeenBlockHash()));
+                        }
+                        if (!walletProto.hasLastSeenBlockHeight()) {
+                            wallet.setLastBlockSeenHeight(-1);
+                        } else {
+                            wallet.setLastBlockSeenHeight(walletProto.getLastSeenBlockHeight());
+                        }
+                        wallet.setLastBlockSeenTimeSecs(walletProto.getLastSeenBlockTimeSecs());
+                        if (walletProto.hasKeyRotationTime()) {
+                            wallet.setKeyRotationTime(new Date(walletProto.getKeyRotationTime() * 1000));
+                        }
+                    }
+
+                    for (Protos.Tag tag : walletProto.getTagsList()) {
+                        wallet.setTag(tag.getTag(), tag.getData());
                     }
+                    if (walletProto.hasVersion()) {
+                        wallet.setVersion(walletProto.getVersion());
+                    }
+
+                    long totalTime = System.currentTimeMillis() - methodStart;
+                    log.info("readWallet (parallel={}, threads={}) timing: {}ms total, keys={}ms, friendRecv={}ms, friendSend={}ms, tx={}ms[{}tx], ext={}ms, connect={}ms, addWallet={}ms",
+                            complexityScore, numThreads, totalTime, keysTime[0], friendRecvTime[0], friendSendTime[0],
+                            txTime[0], walletProto.getTransactionCount(), extTime, connectTime, addWalletTime[0]);
+                    return wallet;
+                } finally {
+                    executor.shutdown();
                 }
+            } else {
+                // Serial path for small wallets
+                // Read the scrypt parameters that specify how encryption and decryption is performed.
+                KeyChainGroup keyChainGroup;
+                if (walletProto.hasEncryptionParameters()) {
+                    Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
+                    final KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
+                    keyChainGroup = KeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeyList(), keyCrypter, effectiveFactory);
+                } else {
+                    keyChainGroup = KeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeyList(), effectiveFactory);
+                }
+                Wallet wallet = factory.create(params, keyChainGroup);
 
-                if (friendSendFuture != null) {
+                List<Script> scripts = Lists.newArrayList();
+                for (Protos.Script protoScript : walletProto.getWatchedScriptList()) {
                     try {
-                        wallet.setSendingToFriendsGroup(friendSendFuture.get());
-                    } catch (ExecutionException e) {
-                        Throwable cause = e.getCause();
-                        if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
-                        throw new UnreadableWalletException("Failed to parse sending friend keys", e);
-                    } catch (InterruptedException e) {
-                        Thread.currentThread().interrupt();
-                        throw new UnreadableWalletException("Interrupted while parsing sending friend keys");
+                        Script script =
+                                new Script(protoScript.getProgram().toByteArray(),
+                                        protoScript.getCreationTimestamp() / 1000);
+                        scripts.add(script);
+                    } catch (ScriptException e) {
+                        throw new UnreadableWalletException("Unparseable script in wallet");
                     }
                 }
 
+                //read the keys for friends (they send, we spend)
+                if (walletProto.getKeysForFriendsCount() > 0) {
+                    FriendKeyChainGroup friendKeyChainGroup;
+                    if (walletProto.hasEncryptionParameters()) {
+                        Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
+                        KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
+                        friendKeyChainGroup = FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysForFriendsList(), keyCrypter, effectiveFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
+                    } else {
+                        friendKeyChainGroup = FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysForFriendsList(), effectiveFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
+                    }
+                    wallet.setReceivingFromFriendsGroup(friendKeyChainGroup);
+                }
+
+                if (walletProto.getKeysFromFriendsCount() > 0) {
+                    FriendKeyChainGroup friendKeyChainGroup;
+                    if (walletProto.hasEncryptionParameters()) {
+                        Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
+                        KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
+                        friendKeyChainGroup = FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysFromFriendsList(), keyCrypter, effectiveFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
+                    } else {
+                        friendKeyChainGroup = FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysFromFriendsList(), effectiveFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
+                    }
+                    wallet.setSendingToFriendsGroup(friendKeyChainGroup);
+                }
+
                 wallet.addWatchedScripts(scripts);
+
                 if (walletProto.hasDescription()) {
                     wallet.setDescription(walletProto.getDescription());
                 }
 
                 // load extensions before processing transactions
-                long extStart = System.currentTimeMillis();
                 loadExtensions(wallet, extensions != null ? extensions : new WalletExtension[0], walletProto);
-                long extTime = System.currentTimeMillis() - extStart;
-                log.info("readWallet: loadExtensions done in {}ms", extTime);
 
-                long connectTime = 0;
                 if (forceReset) {
+                    // Should mirror Wallet.reset()
                     wallet.setLastBlockSeenHash(null);
                     wallet.setLastBlockSeenHeight(-1);
                     wallet.setLastBlockSeenTimeSecs(0);
                 } else {
-                    // Wait for all transaction futures, then populate txMap
-                    if (!txFutures.isEmpty()) {
-                        try {
-                            CompletableFuture.allOf(txFutures.toArray(new CompletableFuture[0])).get();
-                        } catch (ExecutionException e) {
-                            Throwable cause = e.getCause();
-                            if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
-                                throw (UnreadableWalletException) cause.getCause();
-                            if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
-                            throw new UnreadableWalletException("Failed to parse transactions", e);
-                        } catch (InterruptedException e) {
-                            Thread.currentThread().interrupt();
-                            throw new UnreadableWalletException("Interrupted while parsing transactions");
-                        }
-                    }
-                    txTime[0] = System.currentTimeMillis() - txFuturesStart;
-                    log.info("readWallet: tx threads done in {}ms ({} transactions)", txTime[0], parsedTxs.size());
-                    txMap.putAll(parsedTxs);
-
-                    // Connect outputs in parallel: txMap is fully populated and read-only here.
-                    // Each call only touches its own tx's outputs and unique inputs of spending txs,
-                    // so concurrent calls do not write to the same fields.
-                    long connectStart = System.currentTimeMillis();
-                    List<Protos.Transaction> txProtoList = walletProto.getTransactionList();
-                    final WalletTransaction[] walletTxns = new WalletTransaction[txProtoList.size()];
-                    int connectBatchSize = Math.max(1, (txProtoList.size() + numThreads + 2) / (numThreads + 3));
-                    List<CompletableFuture<Void>> connectFutures = new ArrayList<>(numThreads);
-                    for (int i = 0; i < txProtoList.size(); i += connectBatchSize) {
-                        final int from = i;
-                        final int to = Math.min(i + connectBatchSize, txProtoList.size());
-                        connectFutures.add(CompletableFuture.runAsync(() -> {
-                            for (int j = from; j < to; j++) {
-                                try {
-                                    walletTxns[j] = connectTransactionOutputs(params, txProtoList.get(j));
-                                } catch (UnreadableWalletException e) {
-                                    throw new RuntimeException(e);
-                                }
-                            }
-                        }, executor));
+                    // Read all transactions and insert into the txMap.
+                    for (Protos.Transaction txProto : walletProto.getTransactionList()) {
+                        readTransaction(txProto, wallet.getParams());
                     }
-                    try {
-                        CompletableFuture.allOf(connectFutures.toArray(new CompletableFuture[0])).get();
-                    } catch (ExecutionException e) {
-                        Throwable cause = e.getCause();
-                        if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
-                            throw (UnreadableWalletException) cause.getCause();
-                        if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
-                        throw new UnreadableWalletException("Failed to connect transaction outputs", e);
-                    } catch (InterruptedException e) {
-                        Thread.currentThread().interrupt();
-                        throw new UnreadableWalletException("Interrupted while connecting transaction outputs");
-                    }
-                    connectTime = System.currentTimeMillis() - connectStart;
-                    log.info("readWallet: connectOutputs done in {}ms (parallel)", connectTime);
 
-                    // Add to wallet sequentially (addWalletTransaction acquires write lock per call)
-                    long addWalletStart = System.currentTimeMillis();
-                    for (WalletTransaction wtx : walletTxns) {
+                    // Update transaction outputs to point to inputs that spend them
+                    for (Protos.Transaction txProto : walletProto.getTransactionList()) {
+                        WalletTransaction wtx = connectTransactionOutputs(params, txProto);
                         wallet.addWalletTransaction(wtx);
                     }
-                    addWalletTime[0] = System.currentTimeMillis() - addWalletStart;
-                    log.info("readWallet: addWalletTransactions done in {}ms ({} txs)", addWalletTime[0], walletTxns.length);
 
+                    // Update the lastBlockSeenHash.
                     if (!walletProto.hasLastSeenBlockHash()) {
                         wallet.setLastBlockSeenHash(null);
                     } else {
@@ -1165,7 +1284,9 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
                     } else {
                         wallet.setLastBlockSeenHeight(walletProto.getLastSeenBlockHeight());
                     }
+                    // Will default to zero if not present.
                     wallet.setLastBlockSeenTimeSecs(walletProto.getLastSeenBlockTimeSecs());
+
                     if (walletProto.hasKeyRotationTime()) {
                         wallet.setKeyRotationTime(new Date(walletProto.getKeyRotationTime() * 1000));
                     }
@@ -1174,126 +1295,17 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
                 for (Protos.Tag tag : walletProto.getTagsList()) {
                     wallet.setTag(tag.getTag(), tag.getData());
                 }
+
                 if (walletProto.hasVersion()) {
                     wallet.setVersion(walletProto.getVersion());
                 }
 
-                txMap.clear();
-                long totalTime = System.currentTimeMillis() - methodStart;
-                log.info("readWallet (parallel={}, threads={}) timing: {}ms total, keys={}ms, friendRecv={}ms, friendSend={}ms, tx={}ms[{}tx], ext={}ms, connect={}ms, addWallet={}ms",
-                        complexityScore, numThreads, totalTime, keysTime[0], friendRecvTime[0], friendSendTime[0],
-                        txTime[0], walletProto.getTransactionCount(), extTime, connectTime, addWalletTime[0]);
                 return wallet;
-            } finally {
-                executor.shutdown();
-            }
-        } else {
-            // Serial path for small wallets
-            // Read the scrypt parameters that specify how encryption and decryption is performed.
-            KeyChainGroup keyChainGroup;
-            if (walletProto.hasEncryptionParameters()) {
-                Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
-                final KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
-                keyChainGroup = KeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeyList(), keyCrypter, keyChainFactory);
-            } else {
-                keyChainGroup = KeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeyList(), keyChainFactory);
-            }
-            Wallet wallet = factory.create(params, keyChainGroup);
-
-            List<Script> scripts = Lists.newArrayList();
-            for (Protos.Script protoScript : walletProto.getWatchedScriptList()) {
-                try {
-                    Script script =
-                            new Script(protoScript.getProgram().toByteArray(),
-                                    protoScript.getCreationTimestamp() / 1000);
-                    scripts.add(script);
-                } catch (ScriptException e) {
-                    throw new UnreadableWalletException("Unparseable script in wallet");
-                }
-            }
-
-            //read the keys for friends (they send, we spend)
-            if (walletProto.getKeysForFriendsCount() > 0) {
-                FriendKeyChainGroup friendKeyChainGroup;
-                if (walletProto.hasEncryptionParameters()) {
-                    Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
-                    KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
-                    friendKeyChainGroup = FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysForFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
-                } else {
-                    friendKeyChainGroup = FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysForFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.RECEIVING_CHAIN);
-                }
-                wallet.setReceivingFromFriendsGroup(friendKeyChainGroup);
-            }
-
-            if (walletProto.getKeysFromFriendsCount() > 0) {
-                FriendKeyChainGroup friendKeyChainGroup;
-                if (walletProto.hasEncryptionParameters()) {
-                    Protos.ScryptParameters encryptionParameters = walletProto.getEncryptionParameters();
-                    KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(encryptionParameters);
-                    friendKeyChainGroup = FriendKeyChainGroup.fromProtobufEncrypted(params, walletProto.getKeysFromFriendsList(), keyCrypter, keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
-                } else {
-                    friendKeyChainGroup = FriendKeyChainGroup.fromProtobufUnencrypted(params, walletProto.getKeysFromFriendsList(), keyChainFactory, FriendKeyChain.KeyChainType.SENDING_CHAIN);
-                }
-                wallet.setSendingToFriendsGroup(friendKeyChainGroup);
-            }
-
-            wallet.addWatchedScripts(scripts);
-
-            if (walletProto.hasDescription()) {
-                wallet.setDescription(walletProto.getDescription());
             }
-
-            // load extensions before processing transactions
-            loadExtensions(wallet, extensions != null ? extensions : new WalletExtension[0], walletProto);
-
-            if (forceReset) {
-                // Should mirror Wallet.reset()
-                wallet.setLastBlockSeenHash(null);
-                wallet.setLastBlockSeenHeight(-1);
-                wallet.setLastBlockSeenTimeSecs(0);
-            } else {
-                // Read all transactions and insert into the txMap.
-                for (Protos.Transaction txProto : walletProto.getTransactionList()) {
-                    readTransaction(txProto, wallet.getParams());
-                }
-
-                // Update transaction outputs to point to inputs that spend them
-                for (Protos.Transaction txProto : walletProto.getTransactionList()) {
-                    WalletTransaction wtx = connectTransactionOutputs(params, txProto);
-                    wallet.addWalletTransaction(wtx);
-                }
-
-                // Update the lastBlockSeenHash.
-                if (!walletProto.hasLastSeenBlockHash()) {
-                    wallet.setLastBlockSeenHash(null);
-                } else {
-                    wallet.setLastBlockSeenHash(byteStringToHash(walletProto.getLastSeenBlockHash()));
-                }
-                if (!walletProto.hasLastSeenBlockHeight()) {
-                    wallet.setLastBlockSeenHeight(-1);
-                } else {
-                    wallet.setLastBlockSeenHeight(walletProto.getLastSeenBlockHeight());
-                }
-                // Will default to zero if not present.
-                wallet.setLastBlockSeenTimeSecs(walletProto.getLastSeenBlockTimeSecs());
-
-                if (walletProto.hasKeyRotationTime()) {
-                    wallet.setKeyRotationTime(new Date(walletProto.getKeyRotationTime() * 1000));
-                }
-            }
-
-            for (Protos.Tag tag : walletProto.getTagsList()) {
-                wallet.setTag(tag.getTag(), tag.getData());
-            }
-
-            if (walletProto.hasVersion()) {
-                wallet.setVersion(walletProto.getVersion());
-            }
-
-            // Make sure the object can be re-used to read another wallet without corruption.
+        } finally {
+            // Make sure the object can be re-used to read another wallet without corruption,
+            // even if loadExtensions, connectTransactionOutputs, or addWalletTransaction throws.
             txMap.clear();
-
-            return wallet;
         }
     }
 

From d1c9d0638b84c9c92bf976e47a4670903818c57f Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Sun, 5 Apr 2026 14:38:49 -0700
Subject: [PATCH 17/22] fix: add forceMerge to MasternodeSeedPeers

---
 .../net/discovery/MasternodeSeedPeers.java       | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/net/discovery/MasternodeSeedPeers.java b/core/src/main/java/org/bitcoinj/net/discovery/MasternodeSeedPeers.java
index 96c2e3b419..67241a94e9 100644
--- a/core/src/main/java/org/bitcoinj/net/discovery/MasternodeSeedPeers.java
+++ b/core/src/main/java/org/bitcoinj/net/discovery/MasternodeSeedPeers.java
@@ -38,8 +38,8 @@ public class MasternodeSeedPeers implements PeerDiscovery {
     private int pnseedIndex;
 
     // if there are more than 20 masternodes, then don't use HP masternodes in peer discovery
-    private static String[] mergeArrays(String[] masternodeArray, String[] hpMasternodeArray) {
-        if (masternodeArray.length > ENOUGH_MASTERNODES || hpMasternodeArray.length == 0) {
+    private static String[] mergeArrays(String[] masternodeArray, String[] hpMasternodeArray, boolean forceMerge) {
+        if (!forceMerge && (masternodeArray.length > ENOUGH_MASTERNODES || hpMasternodeArray.length == 0)) {
             return masternodeArray;
         } else {
             String[] result = Arrays.copyOf(masternodeArray, masternodeArray.length + hpMasternodeArray.length);
@@ -53,7 +53,17 @@ private static String[] mergeArrays(String[] masternodeArray, String[] hpMastern
      * @param params Network parameters to be used for port information.
      */
     public MasternodeSeedPeers(NetworkParameters params) {
-        this(mergeArrays(params.getDefaultMasternodeList(), params.getDefaultHPMasternodeList()), params);
+        this(mergeArrays(params.getDefaultMasternodeList(), params.getDefaultHPMasternodeList(), false), params);
+    }
+
+    /**
+     * Supports finding peers by IP addresses
+     *
+     * @param params Network parameters to be used for port information.
+     * @param forceMerge forces merging of all masternode lists
+     */
+    public MasternodeSeedPeers(NetworkParameters params, boolean forceMerge) {
+        this(mergeArrays(params.getDefaultMasternodeList(), params.getDefaultHPMasternodeList(), forceMerge), params);
     }
 
     /**

From 1e7e69b513402e1bb65d404c720da59b81a24527 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Sun, 5 Apr 2026 14:39:14 -0700
Subject: [PATCH 18/22] fix: update hp masternode list

---
 .../org/bitcoinj/params/TestNet3Params.java   | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/params/TestNet3Params.java b/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
index 95f5845318..5fe9f7df05 100644
--- a/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
+++ b/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
@@ -233,34 +233,34 @@ public String getPaymentProtocolId() {
     };
 
     public String [] HP_MASTERNODES = {
-        "34.214.48.68",
-        "35.166.18.166",
+        "68.67.122.1",
+        "68.67.122.2",
         "68.67.122.3",
-        "52.42.202.128",
-        "52.12.176.90",
-        "44.233.44.95",
-        "35.167.145.149",
-        "52.34.144.50",
-        "44.240.98.102",
-        "54.201.32.131",
-        "52.10.229.11",
-        "52.13.132.146",
-        "44.228.242.181",
-        "35.82.197.197",
-        "52.40.219.41",
-        "44.239.39.153",
-        "54.149.33.167",
+        "68.67.122.4",
+        "68.67.122.5",
+        "68.67.122.6",
+        "68.67.122.7",
+        "68.67.122.8",
+        "68.67.122.9",
+        "68.67.122.10",
+        "68.67.122.11",
+        "68.67.122.12",
+        "68.67.122.13",
+        "68.67.122.14",
+        "68.67.122.15",
+        "68.67.122.16",
+        "68.67.122.17",
         "68.67.122.18",
-        "52.33.28.47",
-        "52.43.86.231",
-        "52.43.13.92",
+        "68.67.122.19",
+        "68.67.122.20",
+        "68.67.122.21",
         "68.67.122.22",
-        "52.89.154.48",
-        "52.24.124.162",
-        "44.227.137.77",
-        "35.85.21.179",
-        "54.187.14.232",
-        "54.68.235.201",
+        "68.67.122.23",
+        "68.67.122.24",
+        "68.67.122.25",
+        "68.67.122.26",
+        "68.67.122.27",
+        "68.67.122.28",
         "68.67.122.29"
     };
 

From a1eb08778396fa2ccdb1e256cec454da67a25dfb Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Sun, 5 Apr 2026 14:45:20 -0700
Subject: [PATCH 19/22] fix: update PortOpen to check seeds and masternode
 lists of the network

---
 .../java/org/bitcoinj/examples/PortOpen.java  | 21 ++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/examples/src/main/java/org/bitcoinj/examples/PortOpen.java b/examples/src/main/java/org/bitcoinj/examples/PortOpen.java
index 64ec76fac7..f047fa8ddf 100644
--- a/examples/src/main/java/org/bitcoinj/examples/PortOpen.java
+++ b/examples/src/main/java/org/bitcoinj/examples/PortOpen.java
@@ -15,6 +15,7 @@
 package org.bitcoinj.examples;
 
 import org.bitcoinj.core.NetworkParameters;
+import org.bitcoinj.net.discovery.MasternodeSeedPeers;
 import org.bitcoinj.net.discovery.PeerDiscoveryException;
 import org.bitcoinj.net.discovery.SeedPeers;
 import org.bitcoinj.params.MainNetParams;
@@ -60,13 +61,31 @@ public static void main(String[] args) {
             int index = 0;
             int notAvailable = 0;
             for (InetSocketAddress address : seedPeers.getPeers(0, 10, TimeUnit.SECONDS)) {
+                System.out.print("seed ");
                 System.out.print(address.getAddress());
                 boolean available = serverListening(address.getAddress().getHostAddress(), params.getPort());
                 System.out.println(" is " + (available ? "available" : "not available"));
                 index++;
                 notAvailable += available ? 0 : 1;
             }
-            System.out.println((notAvailable * 100 / index) + "% are not available");
+            System.out.println((notAvailable * 100 / index) + "% of seeds are not available");
+        } catch (PeerDiscoveryException x) {
+            System.out.println("Error: " + x.getMessage());
+        }
+
+        MasternodeSeedPeers masternodeSeedPeers = new MasternodeSeedPeers(params, true);
+        try {
+            int index = 0;
+            int notAvailable = 0;
+            for (InetSocketAddress address : masternodeSeedPeers.getPeers(0, 10, TimeUnit.SECONDS)) {
+                System.out.print("masternode ");
+                System.out.print(address.getAddress());
+                boolean available = serverListening(address.getAddress().getHostAddress(), params.getPort());
+                System.out.println(" is " + (available ? "available" : "not available"));
+                index++;
+                notAvailable += available ? 0 : 1;
+            }
+            System.out.println((notAvailable * 100 / index) + "% of masternodes(regular, hp) are not available");
         } catch (PeerDiscoveryException x) {
             System.out.println("Error: " + x.getMessage());
         }

From 3044cc3e6b7e37c99575a21a67104bdb2f1bf238 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Sun, 5 Apr 2026 16:08:13 -0700
Subject: [PATCH 20/22] fix: prevent divide by zero bug in PortOpen

---
 .../main/java/org/bitcoinj/examples/PortOpen.java    | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/examples/src/main/java/org/bitcoinj/examples/PortOpen.java b/examples/src/main/java/org/bitcoinj/examples/PortOpen.java
index f047fa8ddf..6cf5cb9bc6 100644
--- a/examples/src/main/java/org/bitcoinj/examples/PortOpen.java
+++ b/examples/src/main/java/org/bitcoinj/examples/PortOpen.java
@@ -68,7 +68,11 @@ public static void main(String[] args) {
                 index++;
                 notAvailable += available ? 0 : 1;
             }
-            System.out.println((notAvailable * 100 / index) + "% of seeds are not available");
+            if (index != 0) {
+                System.out.println((notAvailable * 100 / index) + "% of seeds are not available");
+            } else {
+                System.out.println("no seeds are specified");
+            }
         } catch (PeerDiscoveryException x) {
             System.out.println("Error: " + x.getMessage());
         }
@@ -85,7 +89,11 @@ public static void main(String[] args) {
                 index++;
                 notAvailable += available ? 0 : 1;
             }
-            System.out.println((notAvailable * 100 / index) + "% of masternodes(regular, hp) are not available");
+            if (index != 0) {
+                System.out.println((notAvailable * 100 / index) + "% of masternodes(regular, hp) are not available");
+            } else {
+                System.out.println("no masternodes are specified");
+            }
         } catch (PeerDiscoveryException x) {
             System.out.println("Error: " + x.getMessage());
         }

From d88ddf8508c8d5f11272fb26d643d7d2fceded00 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Sun, 5 Apr 2026 16:20:21 -0700
Subject: [PATCH 21/22] fix: handle edge cases to ensure locks are set in the
 tx confidence

---
 .../bitcoinj/quorums/InstantSendManager.java   | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
index 15e16f5172..b7b9ec47f8 100644
--- a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
+++ b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
@@ -549,6 +549,8 @@ HashSet<Sha256Hash> processPendingInstantSendLocks(LLMQParameters.LLMQType llmqT
             // no need to verify an ISLOCK if we already have verified the recovered sig that belongs to it
             if (quorumSigningManager.hasRecoveredSig(llmqType, id, islock.txid)) {
                 log.info("islock: signature has already been verified: {}", islock.txid);
+                // Still apply IX_LOCKED to wallet in case the tx arrived after the lock was verified
+                processInstantSendLock(p.getValue().getFirst(), hash, islock);
                 continue;
             }
 
@@ -1038,6 +1040,22 @@ public boolean notifyTransactionIsInBlock(Sha256Hash txHash, StoredBlock block,
     public void addWallet(Wallet wallet) {
         wallet.addCoinsSentEventListener(coinsSentEventListener);
         wallets.add(wallet);
+        // Backfill any ISLocks that were verified before this wallet was attached
+        for (Transaction tx : wallet.getTransactions(false)) {
+            if (tx.getConfidence().getIXType() == TransactionConfidence.IXType.IX_LOCKED) {
+                continue;
+            }
+            Sha256Hash islockHash = db.getInstantSendLockHashByTxid(tx.getTxId());
+            if (islockHash != null && !islockHash.isZero()) {
+                InstantSendLock islock = db.getInstantSendLockByHash(islockHash);
+                if (islock != null) {
+                    TransactionConfidence confidence = tx.getConfidence();
+                    confidence.setInstantSendLock(islock);
+                    confidence.setIXType(TransactionConfidence.IXType.IX_LOCKED);
+                    confidence.queueListeners(TransactionConfidence.Listener.ChangeReason.IX_TYPE);
+                }
+            }
+        }
     }
 
     public void removeWallet(Wallet wallet) {

From 883b04d3f0d38a72a830847002e7eea74174bcf5 Mon Sep 17 00:00:00 2001
From: HashEngineering <hashengineeringsolutions@gmail.com>
Date: Sun, 5 Apr 2026 16:35:01 -0700
Subject: [PATCH 22/22] fix: coderabbit fixes

---
 .../bitcoinj/quorums/InstantSendManager.java  | 27 ++++++++++---------
 .../wallet/WalletProtobufSerializer.java      |  8 +++++-
 2 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
index b7b9ec47f8..527393534c 100644
--- a/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
+++ b/core/src/main/java/org/bitcoinj/quorums/InstantSendManager.java
@@ -824,19 +824,22 @@ public void syncTransaction(Transaction tx, StoredBlock block, int posInBlock) {
         // re-queue it for processing so the verify path (processInstantSendLock) applies
         // IX_LOCKED. This keeps IX_LOCKED assignment inside the single authoritative path.
         if (!isDisconnect && islockHash != null && !islockHash.isZero()) {
-            InstantSendLock islock = db.getInstantSendLockByHash(islockHash);
-            if (islock != null && tx.getConfidence().getIXType() != TransactionConfidence.IXType.IX_LOCKED) {
-                lock.lock();
-                try {
-                    if (!pendingInstantSendLocks.containsKey(islockHash)) {
-                        pendingInstantSendLocks.put(islockHash, new Pair<>((long) -1, islock));
+            InstantSendLock islock = null;
+            lock.lock();
+            try {
+                islock = db.getInstantSendLockByHash(islockHash);
+                if (islock != null
+                                && tx.getConfidence().getIXType() != TransactionConfidence.IXType.IX_LOCKED
+                                && !pendingInstantSendLocks.containsKey(islockHash)) {
+                        pendingInstantSendLocks.put(islockHash, new Pair<>(-1L, islock));
+                    } else {
+                        islock = null;
                     }
-                } finally {
-                    lock.unlock();
-                }
-                if (runWithoutThread) {
-                    processPendingInstantSendLocks();
-                }
+            } finally {
+                lock.unlock();
+            }
+            if (islock != null && runWithoutThread) {
+                processPendingInstantSendLocks();
             }
         }
     }
diff --git a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
index 04038e8754..0839be7ff5 100644
--- a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
+++ b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
@@ -1053,6 +1053,8 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
                     } catch (ExecutionException e) {
                         Throwable cause = e.getCause();
                         if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                        if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
+                            throw (UnreadableWalletException) cause.getCause();
                         throw new UnreadableWalletException("Failed to parse key chain group", e);
                     } catch (InterruptedException e) {
                         Thread.currentThread().interrupt();
@@ -1066,6 +1068,8 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
                         } catch (ExecutionException e) {
                             Throwable cause = e.getCause();
                             if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                            if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
+                                throw (UnreadableWalletException) cause.getCause();
                             throw new UnreadableWalletException("Failed to parse receiving friend keys", e);
                         } catch (InterruptedException e) {
                             Thread.currentThread().interrupt();
@@ -1079,6 +1083,8 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
                         } catch (ExecutionException e) {
                             Throwable cause = e.getCause();
                             if (cause instanceof UnreadableWalletException) throw (UnreadableWalletException) cause;
+                            if (cause instanceof RuntimeException && cause.getCause() instanceof UnreadableWalletException)
+                                throw (UnreadableWalletException) cause.getCause();
                             throw new UnreadableWalletException("Failed to parse sending friend keys", e);
                         } catch (InterruptedException e) {
                             Thread.currentThread().interrupt();
@@ -1191,7 +1197,7 @@ public Wallet readWallet(NetworkParameters params, @Nullable WalletExtension[] e
 
                     long totalTime = System.currentTimeMillis() - methodStart;
                     log.info("readWallet (parallel={}, threads={}) timing: {}ms total, keys={}ms, friendRecv={}ms, friendSend={}ms, tx={}ms[{}tx], ext={}ms, connect={}ms, addWallet={}ms",
-                            complexityScore, numThreads, totalTime, keysTime[0], friendRecvTime[0], friendSendTime[0],
+                            parallelLoad, numThreads, totalTime, keysTime[0], friendRecvTime[0], friendSendTime[0],
                             txTime[0], walletProto.getTransactionCount(), extTime, connectTime, addWalletTime[0]);
                     return wallet;
                 } finally {