Remove address prefix for mailbox messages

common/src/main/java/bisq/common/app/Capabilities.java

@@ -184,4 +184,18 @@ public String prettyPrint() {
     public int size() {
         return capabilities.size();
     }
+
+    // We return true if our capabilities have less capabilities than the parameter value
+    public boolean hasLess(Capabilities other) {
+        return findHighestCapability(this) < findHighestCapability(other);
+    }
+
+    // We use the sum of all capabilities. Alternatively we could use the highest entry.
+    // Neither would support removal of past capabilities, a use case we never had so far and which might have
+    // backward compatibility issues, so we should treat capabilities as an append-only data structure.
+    public int findHighestCapability(Capabilities capabilities) {
+        return (int) capabilities.capabilities.stream()
+                .mapToLong(e -> (long) e.ordinal())
+                .sum();
+    }
 }

common/src/test/java/bisq/common/app/CapabilitiesTest.java

@@ -23,6 +23,7 @@
 
 import org.junit.Test;
 
+import static bisq.common.app.Capability.DAO_FULL_NODE;
 import static bisq.common.app.Capability.SEED_NODE;
 import static bisq.common.app.Capability.TRADE_STATISTICS;
 import static bisq.common.app.Capability.TRADE_STATISTICS_2;
@@ -40,6 +41,47 @@ public void testNoCapabilitiesAvailable() {
         assertFalse(DUT.containsAll(new Capabilities(SEED_NODE)));
     }
 
+    @Test
+    public void testHasLess() {
+        assertTrue(new Capabilities().hasLess(new Capabilities(SEED_NODE)));
+        assertFalse(new Capabilities().hasLess(new Capabilities()));
+        assertFalse(new Capabilities(SEED_NODE).hasLess(new Capabilities()));
+        assertTrue(new Capabilities(SEED_NODE).hasLess(new Capabilities(DAO_FULL_NODE)));
+        assertFalse(new Capabilities(DAO_FULL_NODE).hasLess(new Capabilities(SEED_NODE)));
+
+        Capabilities all = new Capabilities(
+                Capability.TRADE_STATISTICS,
+                Capability.TRADE_STATISTICS_2,
+                Capability.ACCOUNT_AGE_WITNESS,
+                Capability.ACK_MSG,
+                Capability.PROPOSAL,
+                Capability.BLIND_VOTE,
+                Capability.DAO_STATE,
+                Capability.BUNDLE_OF_ENVELOPES,
+                Capability.MEDIATION,
+                Capability.SIGNED_ACCOUNT_AGE_WITNESS,
+                Capability.REFUND_AGENT,
+                Capability.TRADE_STATISTICS_HASH_UPDATE
+        );
+        Capabilities other = new Capabilities(
+                Capability.TRADE_STATISTICS,
+                Capability.TRADE_STATISTICS_2,
+                Capability.ACCOUNT_AGE_WITNESS,
+                Capability.ACK_MSG,
+                Capability.PROPOSAL,
+                Capability.BLIND_VOTE,
+                Capability.DAO_STATE,
+                Capability.BUNDLE_OF_ENVELOPES,
+                Capability.MEDIATION,
+                Capability.SIGNED_ACCOUNT_AGE_WITNESS,
+                Capability.REFUND_AGENT,
+                Capability.TRADE_STATISTICS_HASH_UPDATE,
+                Capability.NO_ADDRESS_PRE_FIX
+        );
+
+        assertTrue(all.hasLess(other));
+    }
+
     @Test
     public void testO() {
         Capabilities DUT = new Capabilities(TRADE_STATISTICS);

p2p/src/main/java/bisq/network/p2p/peers/PeerManager.java

@@ -417,15 +417,16 @@ public Optional<Capabilities> findPeersCapabilities(NodeAddress nodeAddress) {
                 .map(Peer::getCapabilities);
     }
 
-    private void applyCapabilities(Connection connection, Capabilities capabilities) {
-        if (capabilities == null || capabilities.isEmpty()) {
+    private void applyCapabilities(Connection connection, Capabilities newCapabilities) {
+        if (newCapabilities == null || newCapabilities.isEmpty()) {
             return;
         }
 
         connection.getPeersNodeAddressOptional().ifPresent(nodeAddress -> {
             getAllPeers().stream()
                     .filter(peer -> peer.getNodeAddress().equals(nodeAddress))
-                    .forEach(peer -> peer.setCapabilities(capabilities));
+                    .filter(peer -> peer.getCapabilities().hasLess(newCapabilities))
+                    .forEach(peer -> peer.setCapabilities(newCapabilities));
         });
         requestPersistence();
     }