fix concurrency issues by synchronizing on base persistable list

core/src/main/java/haveno/core/offer/OpenOfferManager.java

@@ -35,6 +35,8 @@
 package haveno.core.offer;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.collect.ImmutableList;
 import com.google.inject.Inject;
 import haveno.common.ThreadUtils;
 import haveno.common.Timer;
@@ -261,7 +263,10 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
     }
 
     private void cleanUpAddressEntries() {
-        Set<String> openOffersIdSet = openOffers.getList().stream().map(OpenOffer::getId).collect(Collectors.toSet());
+        Set<String> openOffersIdSet;
+        synchronized (openOffers.getList()) {
+            openOffersIdSet = openOffers.getList().stream().map(OpenOffer::getId).collect(Collectors.toSet());
+        }
         xmrWalletService.getAddressEntriesForOpenOffer().stream()
                 .filter(e -> !openOffersIdSet.contains(e.getOfferId()))
                 .forEach(e -> {
@@ -292,7 +297,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
             ThreadUtils.execute(() -> {
 
                 // remove offers from offer book
-                synchronized (openOffers) {
+                synchronized (openOffers.getList()) {
                     openOffers.forEach(openOffer -> {
                         if (openOffer.getState() == OpenOffer.State.AVAILABLE) {
                             offerBookService.removeOfferAtShutDown(openOffer.getOffer().getOfferPayload());
@@ -334,6 +339,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
     }
 
     private void removeOpenOffers(List<OpenOffer> openOffers, @Nullable Runnable completeHandler) {
+        synchronized (openOffers) {
             int size = openOffers.size();
             // Copy list as we remove in the loop
             List<OpenOffer> openOffersList = new ArrayList<>(openOffers);
@@ -344,6 +350,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
             if (completeHandler != null)
                 UserThread.runAfter(completeHandler, size * 200 + 500, TimeUnit.MILLISECONDS);
         }
+    }
 
 
     ///////////////////////////////////////////////////////////////////////////////////////////
@@ -450,14 +457,18 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
                 });
 
                 // poll spent status of open offer key images
-                for (OpenOffer openOffer : getOpenOffers()) {
+                synchronized (openOffers.getList()) {
+                    for (OpenOffer openOffer : openOffers.getList()) {
                         xmrConnectionService.getKeyImagePoller().addKeyImages(openOffer.getOffer().getOfferPayload().getReserveTxKeyImages(), OPEN_OFFER_GROUP_KEY_IMAGE_ID);
                     }
+                }
 
                 // poll spent status of signed offer key images
+                synchronized (signedOffers.getList()) {
                     for (SignedOffer signedOffer : signedOffers.getList()) {
                         xmrConnectionService.getKeyImagePoller().addKeyImages(signedOffer.getReserveTxKeyImages(), SIGNED_OFFER_KEY_IMAGE_GROUP_ID);
                     }
+                }
             }, THREAD_ID);
         });
     }
@@ -858,7 +869,6 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
     }
 
     public boolean hasAvailableOpenOffers() {
-        synchronized (openOffers) {
         for (OpenOffer openOffer : getOpenOffers()) {
             if (openOffer.getState() == OpenOffer.State.AVAILABLE) {
                 return true;
@@ -866,22 +876,19 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
         }
         return false;
     }
-    }
 
     public List<OpenOffer> getOpenOffers() {
-        synchronized (openOffers) {
+        synchronized (openOffers.getList()) {
-            return new ArrayList<>(getObservableList());
+            return ImmutableList.copyOf(getObservableList());
         }
     }
 
     public List<OpenOffer> getOpenOfferGroup(String groupId) {
         if (groupId == null) throw new IllegalArgumentException("groupId cannot be null");
-        synchronized (openOffers) {
         return getOpenOffers().stream()
                 .filter(openOffer -> groupId.equals(openOffer.getGroupId()))
                 .collect(Collectors.toList());
     }
-    }
 
     public boolean hasClonedOffer(String offerId) {
         OpenOffer openOffer = getOpenOffer(offerId).orElse(null);
@@ -890,7 +897,6 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
     }
 
     public boolean hasClonedOffers() {
-        synchronized (openOffers) {
         for (OpenOffer openOffer : getOpenOffers()) {
             if (getOpenOfferGroup(openOffer.getGroupId()).size() > 1) {
                 return true;
@@ -898,16 +904,15 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
         }
         return false;
     }
-    }
 
     public List<SignedOffer> getSignedOffers() {
-        synchronized (signedOffers) {
+        synchronized (signedOffers.getList()) {
-            return new ArrayList<>(signedOffers.getObservableList());
+            return ImmutableList.copyOf(signedOffers.getObservableList());
         }
     }
 
     public ObservableList<SignedOffer> getObservableSignedOffersList() {
-        synchronized (signedOffers) {
+        synchronized (signedOffers.getList()) {
             return signedOffers.getObservableList();
         }
     }
@@ -917,9 +922,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
     }
 
     public Optional<OpenOffer> getOpenOffer(String offerId) {
-        synchronized (openOffers) {
+        return getOpenOffers().stream().filter(e -> e.getId().equals(offerId)).findFirst();
-            return openOffers.stream().filter(e -> e.getId().equals(offerId)).findFirst();
-        }
     }
 
     public boolean hasOpenOffer(String offerId) {
@@ -927,14 +930,12 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
     }
 
     public Optional<SignedOffer> getSignedOfferById(String offerId) {
-        synchronized (signedOffers) {
+        return getSignedOffers().stream().filter(e -> e.getOfferId().equals(offerId)).findFirst();
-            return signedOffers.stream().filter(e -> e.getOfferId().equals(offerId)).findFirst();
-        }
     }
 
     private void addOpenOffer(OpenOffer openOffer) {
         log.info("Adding open offer {}", openOffer.getId());
-        synchronized (openOffers) {
+        synchronized (openOffers.getList()) {
             openOffers.add(openOffer);
         }
         if (openOffer.getOffer().getOfferPayload().getReserveTxKeyImages() != null) {
@@ -944,7 +945,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
 
     private void removeOpenOffer(OpenOffer openOffer) {
         log.info("Removing open offer {}", openOffer.getId());
-        synchronized (openOffers) {
+        synchronized (openOffers.getList()) {
             openOffers.remove(openOffer);
         }
         synchronized (placeOfferProtocols) {
@@ -957,17 +958,19 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
     }
 
     private void cancelOpenOffersOnSpent(String keyImage) {
-        for (OpenOffer openOffer : getOpenOffers()) {
+        synchronized (openOffers.getList()) {
+            for (OpenOffer openOffer : openOffers.getList()) {
                 if (openOffer.getOffer().getOfferPayload().getReserveTxKeyImages() != null && openOffer.getOffer().getOfferPayload().getReserveTxKeyImages().contains(keyImage)) {
                     log.warn("Canceling open offer because reserved funds have been spent, offerId={}, state={}", openOffer.getId(), openOffer.getState());
                     cancelOpenOffer(openOffer, null, null);
                 }
             }
         }
+    }
 
     private void addSignedOffer(SignedOffer signedOffer) {
         log.info("Adding SignedOffer for offer {}", signedOffer.getOfferId());
-        synchronized (signedOffers) {
+        synchronized (signedOffers.getList()) {
 
             // remove signed offers with common key images
             for (String keyImage : signedOffer.getReserveTxKeyImages()) {
@@ -982,19 +985,21 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
 
     private void removeSignedOffer(SignedOffer signedOffer) {
         log.info("Removing SignedOffer for offer {}", signedOffer.getOfferId());
-        synchronized (signedOffers) {
+        synchronized (signedOffers.getList()) {
             signedOffers.remove(signedOffer);
-            xmrConnectionService.getKeyImagePoller().removeKeyImages(signedOffer.getReserveTxKeyImages(), SIGNED_OFFER_KEY_IMAGE_GROUP_ID);
         }
+        xmrConnectionService.getKeyImagePoller().removeKeyImages(signedOffer.getReserveTxKeyImages(), SIGNED_OFFER_KEY_IMAGE_GROUP_ID);
     }
 
     private void removeSignedOffers(String keyImage) {
-        for (SignedOffer signedOffer : new ArrayList<SignedOffer>(signedOffers.getList())) {
+        synchronized (signedOffers.getList()) {
+            for (SignedOffer signedOffer : getSignedOffers()) {
                 if (signedOffer.getReserveTxKeyImages().contains(keyImage)) {
                     removeSignedOffer(signedOffer);
                 }
             }
         }
+    }
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Place offer helpers
@@ -2070,7 +2075,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
 
         OpenOffer openOffer = list.remove(0);
         boolean contained = false;
-        synchronized (openOffers) {
+        synchronized (openOffers.getList()) {
             contained = openOffers.contains(openOffer);
         }
         if (contained) {
@@ -2171,7 +2176,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
         if (periodicRefreshOffersTimer == null)
             periodicRefreshOffersTimer = UserThread.runPeriodically(() -> {
                         if (!stopped) {
-                            synchronized (openOffers) {
+                            synchronized (openOffers.getList()) {
                                 int size = openOffers.size();
                                 //we clone our list as openOffers might change during our delayed call
                                 final ArrayList<OpenOffer> openOffersList = new ArrayList<>(openOffers.getList());
@@ -2186,7 +2191,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
                                     UserThread.runAfterRandomDelay(() -> {
                                         // we need to check if in the meantime the offer has been removed
                                         boolean contained = false;
-                                        synchronized (openOffers) {
+                                        synchronized (openOffers.getList()) {
                                             contained = openOffers.contains(openOffer);
                                         }
                                         if (contained) maybeRefreshOffer(openOffer, 0, 1);

core/src/main/java/haveno/core/offer/SignedOfferList.java

@@ -47,11 +47,13 @@ public final class SignedOfferList extends PersistableListAsObservable<SignedOff
 
     @Override
     public Message toProtoMessage() {
+        synchronized (getList()) {
             return protobuf.PersistableEnvelope.newBuilder()
                     .setSignedOfferList(protobuf.SignedOfferList.newBuilder()
                             .addAllSignedOffer(ProtoUtil.collectionToProto(getList(), protobuf.SignedOffer.class)))
                     .build();
         }
+    }
 
     public static SignedOfferList fromProto(protobuf.SignedOfferList proto) {
         List<SignedOffer> list = proto.getSignedOfferList().stream()

core/src/main/java/haveno/core/payment/PaymentAccountList.java

@@ -36,11 +36,13 @@ public class PaymentAccountList extends PersistableList<PaymentAccount> {
 
     @Override
     public Message toProtoMessage() {
+        synchronized (getList()) {
             return protobuf.PersistableEnvelope.newBuilder()
                     .setPaymentAccountList(protobuf.PaymentAccountList.newBuilder()
                             .addAllPaymentAccount(getList().stream().map(PaymentAccount::toProtoMessage).collect(Collectors.toList())))
                     .build();
         }
+    }
 
     public static PaymentAccountList fromProto(protobuf.PaymentAccountList proto, CoreProtoResolver coreProtoResolver) {
         return new PaymentAccountList(new ArrayList<>(proto.getPaymentAccountList().stream()

core/src/main/java/haveno/core/support/dispute/DisputeListService.java

@@ -74,7 +74,9 @@ public abstract class DisputeListService<T extends DisputeList<Dispute>> impleme
     @Override
     public void readPersisted(Runnable completeHandler) {
         persistenceManager.readPersisted(getFileName(), persisted -> {
+            synchronized (persisted.getList()) {
                 disputeList.setAll(persisted.getList());
+            }
             completeHandler.run();
         },
         completeHandler);
@@ -145,10 +147,13 @@ public abstract class DisputeListService<T extends DisputeList<Dispute>> impleme
     private void onDisputesChangeListener(List<? extends Dispute> addedList,
                                           @Nullable List<? extends Dispute> removedList) {
         if (removedList != null) {
+            synchronized (removedList) {
                 removedList.forEach(dispute -> {
                     disputedTradeIds.remove(dispute.getTradeId());
                 });
             }
+        }
+        synchronized (addedList) {
             addedList.forEach(dispute -> {
                 // for each dispute added, keep track of its "BadgeCountProperty"
                 EasyBind.subscribe(dispute.getBadgeCountProperty(),
@@ -166,6 +171,7 @@ public abstract class DisputeListService<T extends DisputeList<Dispute>> impleme
                 disputedTradeIds.add(dispute.getTradeId());
             });
         }
+    }
 
     public void requestPersistence() {
         persistenceManager.requestPersistence();

core/src/main/java/haveno/core/support/dispute/DisputeManager.java

@@ -288,6 +288,7 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
         cleanupDisputes();
 
         List<Dispute> disputes = getDisputeList().getList();
+        synchronized (disputes) {
             disputes.forEach(dispute -> {
                 try {
                     DisputeValidation.validateNodeAddresses(dispute, config);
@@ -296,6 +297,7 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
                     validationExceptions.add(e);
                 }
             });
+        }
 
         maybeClearSensitiveData();
     }
@@ -318,12 +320,14 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
     public void maybeClearSensitiveData() {
         log.info("{} checking closed disputes eligibility for having sensitive data cleared", super.getClass().getSimpleName());
         Instant safeDate = closedTradableManager.getSafeDateForSensitiveDataClearing();
+        synchronized (getDisputeList().getList()) {
             getDisputeList().getList().stream()
                     .filter(e -> e.isClosed())
                     .filter(e -> e.getOpeningDate().toInstant().isBefore(safeDate))
                     .forEach(Dispute::maybeClearSensitiveData);
             requestPersistence();
         }
+    }
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Dispute handling

core/src/main/java/haveno/core/support/dispute/arbitration/ArbitrationManager.java

@@ -176,6 +176,7 @@ public final class ArbitrationManager extends DisputeManager<ArbitrationDisputeL
         // remove disputes opened by arbitrator, which is not allowed
         Set<Dispute> toRemoves = new HashSet<>();
         List<Dispute> disputes = getDisputeList().getList();
+        synchronized (disputes) {
             for (Dispute dispute : disputes) {
 
                 // get dispute's trade
@@ -190,6 +191,7 @@ public final class ArbitrationManager extends DisputeManager<ArbitrationDisputeL
                     toRemoves.add(dispute);
                 }
             }
+        }
         for (Dispute toRemove : toRemoves) {
             log.warn("Removing invalid dispute opened by arbitrator, disputeId={}", toRemove.getTradeId(), toRemove.getId());
             getDisputeList().remove(toRemove);

core/src/main/java/haveno/core/support/dispute/mediation/MediationDisputeList.java

@@ -55,9 +55,11 @@ public final class MediationDisputeList extends DisputeList<Dispute> {
 
     @Override
     public Message toProtoMessage() {
+        synchronized (getList()) {
             return protobuf.PersistableEnvelope.newBuilder().setMediationDisputeList(protobuf.MediationDisputeList.newBuilder()
                     .addAllDispute(ProtoUtil.collectionToProto(getList(), protobuf.Dispute.class))).build();
         }
+    }
 
     public static MediationDisputeList fromProto(protobuf.MediationDisputeList proto,
                                                  CoreProtoResolver coreProtoResolver) {

core/src/main/java/haveno/core/support/dispute/refund/RefundDisputeList.java

@@ -58,10 +58,11 @@ public final class RefundDisputeList extends DisputeList<Dispute> {
     @Override
     public Message toProtoMessage() {
         forEach(dispute -> checkArgument(dispute.getSupportType().equals(SupportType.REFUND), "Support type has to be REFUND"));
-
+        synchronized (getList()) {
             return protobuf.PersistableEnvelope.newBuilder().setRefundDisputeList(protobuf.RefundDisputeList.newBuilder()
                     .addAllDispute(ProtoUtil.collectionToProto(getList(), protobuf.Dispute.class))).build();
         }
+    }
 
     public static RefundDisputeList fromProto(protobuf.RefundDisputeList proto,
                                               CoreProtoResolver coreProtoResolver) {

core/src/main/java/haveno/core/trade/CleanupMailboxMessages.java

@@ -55,6 +55,7 @@ public class CleanupMailboxMessages {
     }
 
     public void handleTrades(List<Trade> trades) {
+        synchronized (trades) {
             // We wrap in a try catch as in failed trades we cannot be sure if expected data is set, so we could get
             // a NullPointer and do not want that this escalate to the user.
             try {
@@ -72,6 +73,7 @@ public class CleanupMailboxMessages {
                 log.error("Cleanup mailbox messages failed. {}", t.toString());
             }
         }
+    }
 
     private void cleanupMailboxMessages(List<Trade> trades) {
         mailboxMessageService.getMyDecryptedMailboxMessages()

core/src/main/java/haveno/core/trade/ClosedTradableManager.java

@@ -81,10 +81,12 @@ public class ClosedTradableManager implements PersistedDataHost {
     @Override
     public void readPersisted(Runnable completeHandler) {
         persistenceManager.readPersisted(persisted -> {
+            synchronized (persisted.getList()) {
                 closedTradables.setAll(persisted.getList());
                 closedTradables.stream()
                         .filter(tradable -> tradable.getOffer() != null)
                         .forEach(tradable -> tradable.getOffer().setPriceFeedService(priceFeedService));
+            }
             completeHandler.run();
         },
         completeHandler);
@@ -96,7 +98,7 @@ public class ClosedTradableManager implements PersistedDataHost {
     }
 
     public void add(Tradable tradable) {
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             if (closedTradables.add(tradable)) {
                 maybeClearSensitiveData();
                 requestPersistence();
@@ -105,7 +107,7 @@ public class ClosedTradableManager implements PersistedDataHost {
     }
 
     public void remove(Tradable tradable) {
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             if (closedTradables.remove(tradable)) {
                 requestPersistence();
             }
@@ -117,17 +119,17 @@ public class ClosedTradableManager implements PersistedDataHost {
     }
 
     public ObservableList<Tradable> getObservableList() {
-        synchronized (closedTradables) {
         return closedTradables.getObservableList();
     }
-    }
 
     public List<Tradable> getTradableList() {
+        synchronized (closedTradables.getList()) {
             return ImmutableList.copyOf(new ArrayList<>(getObservableList()));
         }
+    }
 
     public List<Trade> getClosedTrades() {
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             return ImmutableList.copyOf(getObservableList().stream()
                     .filter(e -> e instanceof Trade)
                     .map(e -> (Trade) e)
@@ -136,7 +138,7 @@ public class ClosedTradableManager implements PersistedDataHost {
     }
 
     public List<OpenOffer> getCanceledOpenOffers() {
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             return ImmutableList.copyOf(getObservableList().stream()
                     .filter(e -> (e instanceof OpenOffer) && ((OpenOffer) e).getState().equals(CANCELED))
                     .map(e -> (OpenOffer) e)
@@ -145,19 +147,19 @@ public class ClosedTradableManager implements PersistedDataHost {
     }
 
     public Optional<Tradable> getTradableById(String id) {
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             return closedTradables.stream().filter(e -> e.getId().equals(id)).findFirst();
         }
     }
 
     public Optional<Trade> getTradeById(String id) {
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             return getClosedTrades().stream().filter(e -> e.getId().equals(id)).findFirst();
         }
     }
 
     public void maybeClearSensitiveData() {
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             log.info("checking closed trades eligibility for having sensitive data cleared");
             closedTradables.stream()
                 .filter(e -> e instanceof Trade)
@@ -170,7 +172,7 @@ public class ClosedTradableManager implements PersistedDataHost {
 
     public boolean canTradeHaveSensitiveDataCleared(String tradeId) {
         Instant safeDate = getSafeDateForSensitiveDataClearing();
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             return closedTradables.stream()
                     .filter(e -> e.getId().equals(tradeId))
                     .filter(e -> e.getDate().toInstant().isBefore(safeDate))
@@ -205,10 +207,12 @@ public class ClosedTradableManager implements PersistedDataHost {
     }
 
     public BigInteger getTotalTradeFee(List<Tradable> tradableList) {
+        synchronized (tradableList) {
             return BigInteger.valueOf(tradableList.stream()
                     .mapToLong(tradable -> getTradeFee(tradable).longValueExact())
                     .sum());
         }
+    }
 
     private BigInteger getTradeFee(Tradable tradable) {
         return getXmrTradeFee(tradable);
@@ -229,7 +233,7 @@ public class ClosedTradableManager implements PersistedDataHost {
     }
 
     public void removeTrade(Trade trade) {
-        synchronized (closedTradables) {
+        synchronized (closedTradables.getList()) {
             if (closedTradables.remove(trade)) {
                 requestPersistence();
             }

core/src/main/java/haveno/core/trade/TradeManager.java

@@ -269,10 +269,12 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
     @Override
     public void readPersisted(Runnable completeHandler) {
         persistenceManager.readPersisted(persisted -> {
+            synchronized (persisted.getList()) {
                 tradableList.setAll(persisted.getList());
                 tradableList.stream()
                         .filter(trade -> trade.getOffer() != null)
                         .forEach(trade -> trade.getOffer().setPriceFeedService(priceFeedService));
+            }
             completeHandler.run();
         },
         completeHandler);
@@ -992,7 +994,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
         log.info("TradeManager.removeTrade() " + trade.getId());
         
         // remove trade
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             if (!tradableList.remove(trade)) return;
         }
 
@@ -1036,7 +1038,8 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
 
     private void updateTradePeriodState() {
         if (isShutDownStarted) return;
-        for (Trade trade : new ArrayList<Trade>(tradableList.getList())) {
+        synchronized (tradableList.getList()) {
+            for (Trade trade : tradableList.getList()) {
                 if (!trade.isPayoutPublished()) {
                     Date maxTradePeriodDate = trade.getMaxTradePeriodDate();
                     Date halfTradePeriodDate = trade.getHalfTradePeriodDate();
@@ -1053,6 +1056,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
                 }
             }
         }
+    }
 
 
     ///////////////////////////////////////////////////////////////////////////////////////////
@@ -1093,7 +1097,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
     }
 
     public Stream<Trade> getTradesStreamWithFundsLockedIn() {
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             return getObservableList().stream().filter(Trade::isFundsLockedIn);
         }
     }
@@ -1108,7 +1112,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
 
     public Set<String> getSetOfFailedOrClosedTradeIdsFromLockedInFunds() throws TradeTxException {
         AtomicReference<TradeTxException> tradeTxException = new AtomicReference<>();
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             Set<String> tradesIdSet = getTradesStreamWithFundsLockedIn()
                     .filter(Trade::hasFailed)
                     .map(Trade::getId)
@@ -1170,7 +1174,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
         initPersistedTrade(trade);
 
         UserThread.execute(() -> {
-            synchronized (tradableList) {
+            synchronized (tradableList.getList()) {
                 if (!tradableList.contains(trade)) {
                     tradableList.add(trade);
                 }
@@ -1241,7 +1245,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
     }
 
     public ObservableList<Trade> getObservableList() {
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             return tradableList.getObservableList();
         }
     }
@@ -1274,33 +1278,33 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
     }
 
     public Optional<Trade> getOpenTrade(String tradeId) {
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             return tradableList.stream().filter(e -> e.getId().equals(tradeId)).findFirst();
         }
     }
 
     public boolean hasOpenTrade(Trade trade) {
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             return tradableList.contains(trade);
         }
     }
 
     public boolean hasFailedScheduledTrade(String offerId) {
-        synchronized (failedTradesManager) {
         return failedTradesManager.getTradeById(offerId).isPresent() && failedTradesManager.getTradeById(offerId).get().isProtocolErrorHandlingScheduled();
     }
-    }
 
     public Optional<Trade> getOpenTradeByUid(String tradeUid) {
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             return tradableList.stream().filter(e -> e.getUid().equals(tradeUid)).findFirst();
         }
     }
 
     public List<Trade> getAllTrades() {
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             List<Trade> trades = new ArrayList<Trade>();
+            synchronized (tradableList.getList()) {
                 trades.addAll(tradableList.getList());
+            }
             trades.addAll(closedTradableManager.getClosedTrades());
             trades.addAll(failedTradesManager.getObservableList());
             return trades;
@@ -1308,7 +1312,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
     }
 
     public List<Trade> getOpenTrades() {
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             return ImmutableList.copyOf(getObservableList().stream()
                     .filter(e -> e instanceof Trade)
                     .map(e -> e)
@@ -1329,7 +1333,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
     }
 
     private void addTrade(Trade trade) {
-        synchronized (tradableList) {
+        synchronized (tradableList.getList()) {
             if (tradableList.add(trade)) {
                 requestPersistence();
             }

core/src/main/java/haveno/core/trade/failed/FailedTradesManager.java

@@ -70,10 +70,12 @@ public class FailedTradesManager implements PersistedDataHost {
     @Override
     public void readPersisted(Runnable completeHandler) {
         persistenceManager.readPersisted(persisted -> {
+            synchronized (persisted.getList()) {
                 failedTrades.setAll(persisted.getList());
                 failedTrades.stream()
                         .filter(trade -> trade.getOffer() != null)
                         .forEach(trade -> trade.getOffer().setPriceFeedService(priceFeedService));
+            }
             completeHandler.run();
         },
         completeHandler);
@@ -84,7 +86,7 @@ public class FailedTradesManager implements PersistedDataHost {
     }
 
     public void add(Trade trade) {
-        synchronized (failedTrades) {
+        synchronized (failedTrades.getList()) {
             if (failedTrades.add(trade)) {
                 requestPersistence();
             }
@@ -92,7 +94,7 @@ public class FailedTradesManager implements PersistedDataHost {
     }
 
     public void removeTrade(Trade trade) {
-        synchronized (failedTrades) {
+        synchronized (failedTrades.getList()) {
             if (failedTrades.remove(trade)) {
                 requestPersistence();
             }
@@ -104,26 +106,26 @@ public class FailedTradesManager implements PersistedDataHost {
     }
 
     public ObservableList<Trade> getObservableList() {
-        synchronized (failedTrades) {
+        synchronized (failedTrades.getList()) {
             return failedTrades.getObservableList();
         }
     }
 
     public Optional<Trade> getTradeById(String id) {
-        synchronized (failedTrades) {
+        synchronized (failedTrades.getList()) {
             return failedTrades.stream().filter(e -> e.getId().equals(id)).findFirst();
         }
     }
 
     public Stream<Trade> getTradesStreamWithFundsLockedIn() {
-        synchronized (failedTrades) {
+        synchronized (failedTrades.getList()) {
             return failedTrades.stream()
                     .filter(Trade::isFundsLockedIn);
         }
     }
 
     public void unFailTrade(Trade trade) {
-        synchronized (failedTrades) {
+        synchronized (failedTrades.getList()) {
             if (unFailTradeCallback == null)
                 return;
 

desktop/src/main/java/haveno/desktop/main/offer/signedoffer/SignedOffersDataModel.java

@@ -62,7 +62,9 @@ class SignedOffersDataModel extends ActivatableDataModel {
     private void applyList() {
         list.clear();
 
+        synchronized (openOfferManager.getObservableSignedOffersList()) {
             list.addAll(openOfferManager.getObservableSignedOffersList().stream().map(SignedOfferListItem::new).collect(Collectors.toList()));
+        }
 
         // we sort by date, the earliest first
         list.sort((o1, o2) -> new Date(o2.getSignedOffer().getTimeStamp()).compareTo(new Date(o1.getSignedOffer().getTimeStamp())));

desktop/src/main/java/haveno/desktop/util/GUIUtil.java

@@ -206,6 +206,7 @@ public class GUIUtil {
                 persistenceManager.readPersisted(fileName, persisted -> {
                             StringBuilder msg = new StringBuilder();
                             HashSet<PaymentAccount> paymentAccounts = new HashSet<>();
+                            synchronized (persisted.getList()) {
                                 persisted.getList().forEach(paymentAccount -> {
                                     String id = paymentAccount.getId();
                                     if (user.getPaymentAccount(id) == null) {
@@ -215,6 +216,7 @@ public class GUIUtil {
                                         msg.append(Res.get("guiUtil.accountImport.noImport", id));
                                     }
                                 });
+                            }
                             user.addImportedPaymentAccounts(paymentAccounts);
                             new Popup().feedback(Res.get("guiUtil.accountImport.imported", path, msg)).show();
                         },

p2p/src/main/java/haveno/network/p2p/mailbox/MailboxMessageList.java

@@ -48,6 +48,7 @@ public class MailboxMessageList extends PersistableList<MailboxItem> {
 
     @Override
     public Message toProtoMessage() {
+        synchronized (getList()) {
             return protobuf.PersistableEnvelope.newBuilder()
                     .setMailboxMessageList(protobuf.MailboxMessageList.newBuilder()
                             .addAllMailboxItem(getList().stream()
@@ -55,6 +56,7 @@ public class MailboxMessageList extends PersistableList<MailboxItem> {
                                     .collect(Collectors.toList())))
                     .build();
         }
+    }
 
     public static MailboxMessageList fromProto(protobuf.MailboxMessageList proto,
                                                NetworkProtoResolver networkProtoResolver) {