nmode's Git Repositories - signal-cli/blob - lib/src/main/java/org/asamk/signal/manager/storage/recipients/RecipientStore.java

   1 package org.asamk.signal.manager.storage.recipients;
   2
   3 import com.fasterxml.jackson.databind.ObjectMapper;
   4
   5 import org.asamk.signal.manager.api.Pair;
   6 import org.asamk.signal.manager.api.UnregisteredRecipientException;
   7 import org.asamk.signal.manager.storage.Utils;
   8 import org.asamk.signal.manager.storage.contacts.ContactsStore;
   9 import org.asamk.signal.manager.storage.profiles.ProfileStore;
  10 import org.signal.libsignal.zkgroup.InvalidInputException;
  11 import org.signal.libsignal.zkgroup.profiles.ProfileKey;
  12 import org.signal.libsignal.zkgroup.profiles.ProfileKeyCredential;
  13 import org.slf4j.Logger;
  14 import org.slf4j.LoggerFactory;
  15 import org.whispersystems.signalservice.api.push.ACI;
  16 import org.whispersystems.signalservice.api.push.ServiceId;
  17 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  18 import org.whispersystems.signalservice.api.util.UuidUtil;
  19
  20 import java.io.ByteArrayInputStream;
  21 import java.io.ByteArrayOutputStream;
  22 import java.io.File;
  23 import java.io.FileInputStream;
  24 import java.io.FileNotFoundException;
  25 import java.io.FileOutputStream;
  26 import java.io.IOException;
  27 import java.util.ArrayList;
  28 import java.util.Base64;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Objects;
  33 import java.util.Optional;
  34 import java.util.Set;
  35 import java.util.UUID;
  36 import java.util.function.Supplier;
  37 import java.util.stream.Collectors;
  38
  39 public class RecipientStore implements RecipientResolver, ContactsStore, ProfileStore {
  40
  41     private final static Logger logger = LoggerFactory.getLogger(RecipientStore.class);
  42
  43     private final ObjectMapper objectMapper;
  44     private final File file;
  45     private final RecipientMergeHandler recipientMergeHandler;
  46     private final SelfAddressProvider selfAddressProvider;
  47
  48     private final Map<RecipientId, Recipient> recipients;
  49     private final Map<Long, Long> recipientsMerged = new HashMap<>();
  50
  51     private long lastId;
  52     private boolean isBulkUpdating;
  53
  54     public static RecipientStore load(
  55             File file, RecipientMergeHandler recipientMergeHandler, SelfAddressProvider selfAddressProvider
  56     ) {
  57         final var objectMapper = Utils.createStorageObjectMapper();
  58         try (var inputStream = new FileInputStream(file)) {
  59             final var storage = objectMapper.readValue(inputStream, Storage.class);
  60
  61             final var recipientStore = new RecipientStore(objectMapper,
  62                     file,
  63                     recipientMergeHandler,
  64                     selfAddressProvider,
  65                     new HashMap<>(),
  66                     storage.lastId);
  67             final var recipients = storage.recipients.stream().map(r -> {
  68                 final var recipientId = new RecipientId(r.id, recipientStore);
  69                 final var address = new RecipientAddress(Optional.ofNullable(r.uuid).map(UuidUtil::parseOrThrow),
  70                         Optional.ofNullable(r.number));
  71
  72                 Contact contact = null;
  73                 if (r.contact != null) {
  74                     contact = new Contact(r.contact.name,
  75                             r.contact.color,
  76                             r.contact.messageExpirationTime,
  77                             r.contact.blocked,
  78                             r.contact.archived);
  79                 }
  80
  81                 ProfileKey profileKey = null;
  82                 if (r.profileKey != null) {
  83                     try {
  84                         profileKey = new ProfileKey(Base64.getDecoder().decode(r.profileKey));
  85                     } catch (InvalidInputException ignored) {
  86                     }
  87                 }
  88
  89                 ProfileKeyCredential profileKeyCredential = null;
  90                 if (r.profileKeyCredential != null) {
  91                     try {
  92                         profileKeyCredential = new ProfileKeyCredential(Base64.getDecoder()
  93                                 .decode(r.profileKeyCredential));
  94                     } catch (Throwable ignored) {
  95                     }
  96                 }
  97
  98                 Profile profile = null;
  99                 if (r.profile != null) {
 100                     profile = new Profile(r.profile.lastUpdateTimestamp,
 101                             r.profile.givenName,
 102                             r.profile.familyName,
 103                             r.profile.about,
 104                             r.profile.aboutEmoji,
 105                             r.profile.avatarUrlPath,
 106                             Profile.UnidentifiedAccessMode.valueOfOrUnknown(r.profile.unidentifiedAccessMode),
 107                             r.profile.capabilities.stream()
 108                                     .map(Profile.Capability::valueOfOrNull)
 109                                     .filter(Objects::nonNull)
 110                                     .collect(Collectors.toSet()));
 111                 }
 112
 113                 return new Recipient(recipientId, address, contact, profileKey, profileKeyCredential, profile);
 114             }).collect(Collectors.toMap(Recipient::getRecipientId, r -> r));
 115
 116             recipientStore.addRecipients(recipients);
 117
 118             return recipientStore;
 119         } catch (FileNotFoundException e) {
 120             logger.trace("Creating new recipient store.");
 121             return new RecipientStore(objectMapper,
 122                     file,
 123                     recipientMergeHandler,
 124                     selfAddressProvider,
 125                     new HashMap<>(),
 126                     0);
 127         } catch (IOException e) {
 128             logger.warn("Failed to load recipient store", e);
 129             throw new RuntimeException(e);
 130         }
 131     }
 132
 133     private RecipientStore(
 134             final ObjectMapper objectMapper,
 135             final File file,
 136             final RecipientMergeHandler recipientMergeHandler,
 137             final SelfAddressProvider selfAddressProvider,
 138             final Map<RecipientId, Recipient> recipients,
 139             final long lastId
 140     ) {
 141         this.objectMapper = objectMapper;
 142         this.file = file;
 143         this.recipientMergeHandler = recipientMergeHandler;
 144         this.selfAddressProvider = selfAddressProvider;
 145         this.recipients = recipients;
 146         this.lastId = lastId;
 147     }
 148
 149     public boolean isBulkUpdating() {
 150         return isBulkUpdating;
 151     }
 152
 153     public void setBulkUpdating(final boolean bulkUpdating) {
 154         isBulkUpdating = bulkUpdating;
 155         if (!bulkUpdating) {
 156             synchronized (recipients) {
 157                 saveLocked();
 158             }
 159         }
 160     }
 161
 162     public RecipientAddress resolveRecipientAddress(RecipientId recipientId) {
 163         synchronized (recipients) {
 164             return getRecipient(recipientId).getAddress();
 165         }
 166     }
 167
 168     public Recipient getRecipient(RecipientId recipientId) {
 169         synchronized (recipients) {
 170             return recipients.get(recipientId);
 171         }
 172     }
 173
 174     @Override
 175     public RecipientId resolveRecipient(ServiceId serviceId) {
 176         return resolveRecipient(new RecipientAddress(serviceId.uuid()), false, false);
 177     }
 178
 179     @Override
 180     public RecipientId resolveRecipient(final long recipientId) {
 181         final var recipient = getRecipient(new RecipientId(recipientId, this));
 182         return recipient == null ? null : recipient.getRecipientId();
 183     }
 184
 185     @Override
 186     public RecipientId resolveRecipient(final String identifier) {
 187         return resolveRecipient(Utils.getRecipientAddressFromIdentifier(identifier), false, false);
 188     }
 189
 190     public RecipientId resolveRecipient(
 191             final String number, Supplier<ACI> aciSupplier
 192     ) throws UnregisteredRecipientException {
 193         final Optional<Recipient> byNumber;
 194         synchronized (recipients) {
 195             byNumber = findByNumberLocked(number);
 196         }
 197         if (byNumber.isEmpty() || byNumber.get().getAddress().uuid().isEmpty()) {
 198             final var aci = aciSupplier.get();
 199             if (aci == null) {
 200                 throw new UnregisteredRecipientException(new RecipientAddress(null, number));
 201             }
 202
 203             return resolveRecipient(new RecipientAddress(aci.uuid(), number), false, false);
 204         }
 205         return byNumber.get().getRecipientId();
 206     }
 207
 208     public RecipientId resolveRecipient(RecipientAddress address) {
 209         return resolveRecipient(address, false, false);
 210     }
 211
 212     @Override
 213     public RecipientId resolveRecipient(final SignalServiceAddress address) {
 214         return resolveRecipient(new RecipientAddress(address), false, false);
 215     }
 216
 217     public RecipientId resolveSelfRecipientTrusted(RecipientAddress address) {
 218         return resolveRecipient(address, true, true);
 219     }
 220
 221     public RecipientId resolveRecipientTrusted(RecipientAddress address) {
 222         return resolveRecipient(address, true, false);
 223     }
 224
 225     public RecipientId resolveRecipientTrusted(SignalServiceAddress address) {
 226         return resolveRecipient(new RecipientAddress(address), true, false);
 227     }
 228
 229     public List<RecipientId> resolveRecipientsTrusted(List<RecipientAddress> addresses) {
 230         final List<RecipientId> recipientIds;
 231         final List<Pair<RecipientId, RecipientId>> toBeMerged = new ArrayList<>();
 232         synchronized (recipients) {
 233             recipientIds = addresses.stream().map(address -> {
 234                 final var pair = resolveRecipientLocked(address, true, false);
 235                 if (pair.second().isPresent()) {
 236                     toBeMerged.add(new Pair<>(pair.first(), pair.second().get()));
 237                 }
 238                 return pair.first();
 239             }).toList();
 240         }
 241         for (var pair : toBeMerged) {
 242             recipientMergeHandler.mergeRecipients(pair.first(), pair.second());
 243         }
 244         return recipientIds;
 245     }
 246
 247     @Override
 248     public void storeContact(RecipientId recipientId, final Contact contact) {
 249         synchronized (recipients) {
 250             final var recipient = recipients.get(recipientId);
 251             storeRecipientLocked(recipientId, Recipient.newBuilder(recipient).withContact(contact).build());
 252         }
 253     }
 254
 255     @Override
 256     public Contact getContact(RecipientId recipientId) {
 257         final var recipient = getRecipient(recipientId);
 258         return recipient == null ? null : recipient.getContact();
 259     }
 260
 261     @Override
 262     public List<Pair<RecipientId, Contact>> getContacts() {
 263         return recipients.entrySet()
 264                 .stream()
 265                 .filter(e -> e.getValue().getContact() != null)
 266                 .map(e -> new Pair<>(e.getKey(), e.getValue().getContact()))
 267                 .toList();
 268     }
 269
 270     @Override
 271     public void deleteContact(RecipientId recipientId) {
 272         synchronized (recipients) {
 273             final var recipient = recipients.get(recipientId);
 274             storeRecipientLocked(recipientId, Recipient.newBuilder(recipient).withContact(null).build());
 275         }
 276     }
 277
 278     public void deleteRecipientData(RecipientId recipientId) {
 279         synchronized (recipients) {
 280             logger.debug("Deleting recipient data for {}", recipientId);
 281             final var recipient = recipients.get(recipientId);
 282             recipient.getAddress()
 283                     .uuid()
 284                     .ifPresent(uuid -> storeRecipientLocked(recipientId,
 285                             Recipient.newBuilder()
 286                                     .withRecipientId(recipientId)
 287                                     .withAddress(new RecipientAddress(uuid))
 288                                     .build()));
 289         }
 290     }
 291
 292     @Override
 293     public Profile getProfile(final RecipientId recipientId) {
 294         final var recipient = getRecipient(recipientId);
 295         return recipient == null ? null : recipient.getProfile();
 296     }
 297
 298     @Override
 299     public ProfileKey getProfileKey(final RecipientId recipientId) {
 300         final var recipient = getRecipient(recipientId);
 301         return recipient == null ? null : recipient.getProfileKey();
 302     }
 303
 304     @Override
 305     public ProfileKeyCredential getProfileKeyCredential(final RecipientId recipientId) {
 306         final var recipient = getRecipient(recipientId);
 307         return recipient == null ? null : recipient.getProfileKeyCredential();
 308     }
 309
 310     @Override
 311     public void storeProfile(RecipientId recipientId, final Profile profile) {
 312         synchronized (recipients) {
 313             final var recipient = recipients.get(recipientId);
 314             storeRecipientLocked(recipientId, Recipient.newBuilder(recipient).withProfile(profile).build());
 315         }
 316     }
 317
 318     @Override
 319     public void storeProfileKey(RecipientId recipientId, final ProfileKey profileKey) {
 320         synchronized (recipients) {
 321             final var recipient = recipients.get(recipientId);
 322             if (profileKey != null && profileKey.equals(recipient.getProfileKey()) && (
 323                     recipient.getProfile() == null || (
 324                             recipient.getProfile().getUnidentifiedAccessMode() != Profile.UnidentifiedAccessMode.UNKNOWN
 325                                     && recipient.getProfile().getUnidentifiedAccessMode()
 326                                     != Profile.UnidentifiedAccessMode.DISABLED
 327                     )
 328             )) {
 329                 return;
 330             }
 331
 332             final var newRecipient = Recipient.newBuilder(recipient)
 333                     .withProfileKey(profileKey)
 334                     .withProfileKeyCredential(null)
 335                     .withProfile(recipient.getProfile() == null
 336                             ? null
 337                             : Profile.newBuilder(recipient.getProfile()).withLastUpdateTimestamp(0).build())
 338                     .build();
 339             storeRecipientLocked(recipientId, newRecipient);
 340         }
 341     }
 342
 343     @Override
 344     public void storeProfileKeyCredential(RecipientId recipientId, final ProfileKeyCredential profileKeyCredential) {
 345         synchronized (recipients) {
 346             final var recipient = recipients.get(recipientId);
 347             storeRecipientLocked(recipientId,
 348                     Recipient.newBuilder(recipient).withProfileKeyCredential(profileKeyCredential).build());
 349         }
 350     }
 351
 352     public boolean isEmpty() {
 353         synchronized (recipients) {
 354             return recipients.isEmpty();
 355         }
 356     }
 357
 358     private void addRecipients(final Map<RecipientId, Recipient> recipients) {
 359         this.recipients.putAll(recipients);
 360     }
 361
 362     /**
 363      * @param isHighTrust true, if the number/uuid connection was obtained from a trusted source.
 364      *                    Has no effect, if the address contains only a number or a uuid.
 365      */
 366     private RecipientId resolveRecipient(RecipientAddress address, boolean isHighTrust, boolean isSelf) {
 367         final Pair<RecipientId, Optional<RecipientId>> pair;
 368         synchronized (recipients) {
 369             pair = resolveRecipientLocked(address, isHighTrust, isSelf);
 370         }
 371
 372         if (pair.second().isPresent()) {
 373             recipientMergeHandler.mergeRecipients(pair.first(), pair.second().get());
 374         }
 375         return pair.first();
 376     }
 377
 378     private Pair<RecipientId, Optional<RecipientId>> resolveRecipientLocked(
 379             RecipientAddress address, boolean isHighTrust, boolean isSelf
 380     ) {
 381         if (isHighTrust && !isSelf) {
 382             if (selfAddressProvider.getSelfAddress().matches(address)) {
 383                 isHighTrust = false;
 384             }
 385         }
 386         final var byNumber = address.number().isEmpty()
 387                 ? Optional.<Recipient>empty()
 388                 : findByNumberLocked(address.number().get());
 389         final var byUuid = address.uuid().isEmpty()
 390                 ? Optional.<Recipient>empty()
 391                 : findByUuidLocked(address.uuid().get());
 392
 393         if (byNumber.isEmpty() && byUuid.isEmpty()) {
 394             logger.debug("Got new recipient, both uuid and number are unknown");
 395
 396             if (isHighTrust || address.uuid().isEmpty() || address.number().isEmpty()) {
 397                 return new Pair<>(addNewRecipientLocked(address), Optional.empty());
 398             }
 399
 400             return new Pair<>(addNewRecipientLocked(new RecipientAddress(address.uuid().get())), Optional.empty());
 401         }
 402
 403         if (!isHighTrust || address.uuid().isEmpty() || address.number().isEmpty() || byNumber.equals(byUuid)) {
 404             return new Pair<>(byUuid.or(() -> byNumber).map(Recipient::getRecipientId).get(), Optional.empty());
 405         }
 406
 407         if (byNumber.isEmpty()) {
 408             logger.debug("Got recipient {} existing with uuid, updating with high trust number",
 409                     byUuid.get().getRecipientId());
 410             updateRecipientAddressLocked(byUuid.get().getRecipientId(), address);
 411             return new Pair<>(byUuid.get().getRecipientId(), Optional.empty());
 412         }
 413
 414         final var byNumberRecipient = byNumber.get();
 415
 416         if (byUuid.isEmpty()) {
 417             if (byNumberRecipient.getAddress().uuid().isPresent()) {
 418                 logger.debug(
 419                         "Got recipient {} existing with number, but different uuid, so stripping its number and adding new recipient",
 420                         byNumberRecipient.getRecipientId());
 421
 422                 updateRecipientAddressLocked(byNumberRecipient.getRecipientId(),
 423                         new RecipientAddress(byNumberRecipient.getAddress().uuid().get()));
 424                 return new Pair<>(addNewRecipientLocked(address), Optional.empty());
 425             }
 426
 427             logger.debug("Got recipient {} existing with number and no uuid, updating with high trust uuid",
 428                     byNumberRecipient.getRecipientId());
 429             updateRecipientAddressLocked(byNumberRecipient.getRecipientId(), address);
 430             return new Pair<>(byNumberRecipient.getRecipientId(), Optional.empty());
 431         }
 432
 433         final var byUuidRecipient = byUuid.get();
 434
 435         if (byNumberRecipient.getAddress().uuid().isPresent()) {
 436             logger.debug(
 437                     "Got separate recipients for high trust number {} and uuid {}, recipient for number has different uuid, so stripping its number",
 438                     byNumberRecipient.getRecipientId(),
 439                     byUuidRecipient.getRecipientId());
 440
 441             updateRecipientAddressLocked(byNumberRecipient.getRecipientId(),
 442                     new RecipientAddress(byNumberRecipient.getAddress().uuid().get()));
 443             updateRecipientAddressLocked(byUuidRecipient.getRecipientId(), address);
 444             return new Pair<>(byUuidRecipient.getRecipientId(), Optional.empty());
 445         }
 446
 447         logger.debug("Got separate recipients for high trust number {} and uuid {}, need to merge them",
 448                 byNumberRecipient.getRecipientId(),
 449                 byUuidRecipient.getRecipientId());
 450         updateRecipientAddressLocked(byUuidRecipient.getRecipientId(), address);
 451         // Create a fixed RecipientId that won't update its id after merge
 452         final var toBeMergedRecipientId = new RecipientId(byNumberRecipient.getRecipientId().id(), null);
 453         mergeRecipientsLocked(byUuidRecipient.getRecipientId(), toBeMergedRecipientId);
 454         return new Pair<>(byUuidRecipient.getRecipientId(), Optional.of(toBeMergedRecipientId));
 455     }
 456
 457     private RecipientId addNewRecipientLocked(final RecipientAddress address) {
 458         final var nextRecipientId = nextIdLocked();
 459         logger.debug("Adding new recipient {} with address {}", nextRecipientId, address);
 460         storeRecipientLocked(nextRecipientId, new Recipient(nextRecipientId, address, null, null, null, null));
 461         return nextRecipientId;
 462     }
 463
 464     private void updateRecipientAddressLocked(RecipientId recipientId, final RecipientAddress address) {
 465         final var recipient = recipients.get(recipientId);
 466         storeRecipientLocked(recipientId, Recipient.newBuilder(recipient).withAddress(address).build());
 467     }
 468
 469     long getActualRecipientId(long recipientId) {
 470         while (recipientsMerged.containsKey(recipientId)) {
 471             final var newRecipientId = recipientsMerged.get(recipientId);
 472             logger.debug("Using {} instead of {}, because recipients have been merged", newRecipientId, recipientId);
 473             recipientId = newRecipientId;
 474         }
 475         return recipientId;
 476     }
 477
 478     private void storeRecipientLocked(final RecipientId recipientId, final Recipient recipient) {
 479         final var existingRecipient = recipients.get(recipientId);
 480         if (existingRecipient == null || !existingRecipient.equals(recipient)) {
 481             recipients.put(recipientId, recipient);
 482             saveLocked();
 483         }
 484     }
 485
 486     private void mergeRecipientsLocked(RecipientId recipientId, RecipientId toBeMergedRecipientId) {
 487         final var recipient = recipients.get(recipientId);
 488         final var toBeMergedRecipient = recipients.get(toBeMergedRecipientId);
 489         recipients.put(recipientId,
 490                 new Recipient(recipientId,
 491                         recipient.getAddress(),
 492                         recipient.getContact() != null ? recipient.getContact() : toBeMergedRecipient.getContact(),
 493                         recipient.getProfileKey() != null
 494                                 ? recipient.getProfileKey()
 495                                 : toBeMergedRecipient.getProfileKey(),
 496                         recipient.getProfileKeyCredential() != null
 497                                 ? recipient.getProfileKeyCredential()
 498                                 : toBeMergedRecipient.getProfileKeyCredential(),
 499                         recipient.getProfile() != null ? recipient.getProfile() : toBeMergedRecipient.getProfile()));
 500         recipients.remove(toBeMergedRecipientId);
 501         recipientsMerged.put(toBeMergedRecipientId.id(), recipientId.id());
 502         saveLocked();
 503     }
 504
 505     private Optional<Recipient> findByNumberLocked(final String number) {
 506         return recipients.entrySet()
 507                 .stream()
 508                 .filter(entry -> entry.getValue().getAddress().number().isPresent() && number.equals(entry.getValue()
 509                         .getAddress()
 510                         .number()
 511                         .get()))
 512                 .findFirst()
 513                 .map(Map.Entry::getValue);
 514     }
 515
 516     private Optional<Recipient> findByUuidLocked(final UUID uuid) {
 517         return recipients.entrySet()
 518                 .stream()
 519                 .filter(entry -> entry.getValue().getAddress().uuid().isPresent() && uuid.equals(entry.getValue()
 520                         .getAddress()
 521                         .uuid()
 522                         .get()))
 523                 .findFirst()
 524                 .map(Map.Entry::getValue);
 525     }
 526
 527     private RecipientId nextIdLocked() {
 528         return new RecipientId(++this.lastId, this);
 529     }
 530
 531     private void saveLocked() {
 532         if (isBulkUpdating) {
 533             return;
 534         }
 535         final var base64 = Base64.getEncoder();
 536         var storage = new Storage(recipients.entrySet().stream().map(pair -> {
 537             final var recipient = pair.getValue();
 538             final var contact = recipient.getContact() == null
 539                     ? null
 540                     : new Storage.Recipient.Contact(recipient.getContact().getName(),
 541                             recipient.getContact().getColor(),
 542                             recipient.getContact().getMessageExpirationTime(),
 543                             recipient.getContact().isBlocked(),
 544                             recipient.getContact().isArchived());
 545             final var profile = recipient.getProfile() == null
 546                     ? null
 547                     : new Storage.Recipient.Profile(recipient.getProfile().getLastUpdateTimestamp(),
 548                             recipient.getProfile().getGivenName(),
 549                             recipient.getProfile().getFamilyName(),
 550                             recipient.getProfile().getAbout(),
 551                             recipient.getProfile().getAboutEmoji(),
 552                             recipient.getProfile().getAvatarUrlPath(),
 553                             recipient.getProfile().getUnidentifiedAccessMode().name(),
 554                             recipient.getProfile()
 555                                     .getCapabilities()
 556                                     .stream()
 557                                     .map(Enum::name)
 558                                     .collect(Collectors.toSet()));
 559             return new Storage.Recipient(pair.getKey().id(),
 560                     recipient.getAddress().number().orElse(null),
 561                     recipient.getAddress().uuid().map(UUID::toString).orElse(null),
 562                     recipient.getProfileKey() == null
 563                             ? null
 564                             : base64.encodeToString(recipient.getProfileKey().serialize()),
 565                     recipient.getProfileKeyCredential() == null
 566                             ? null
 567                             : base64.encodeToString(recipient.getProfileKeyCredential().serialize()),
 568                     contact,
 569                     profile);
 570         }).toList(), lastId);
 571
 572         // Write to memory first to prevent corrupting the file in case of serialization errors
 573         try (var inMemoryOutput = new ByteArrayOutputStream()) {
 574             objectMapper.writeValue(inMemoryOutput, storage);
 575
 576             var input = new ByteArrayInputStream(inMemoryOutput.toByteArray());
 577             try (var outputStream = new FileOutputStream(file)) {
 578                 input.transferTo(outputStream);
 579             }
 580         } catch (Exception e) {
 581             logger.error("Error saving recipient store file: {}", e.getMessage());
 582         }
 583     }
 584
 585     private record Storage(List<Recipient> recipients, long lastId) {
 586
 587         private record Recipient(
 588                 long id,
 589                 String number,
 590                 String uuid,
 591                 String profileKey,
 592                 String profileKeyCredential,
 593                 Storage.Recipient.Contact contact,
 594                 Storage.Recipient.Profile profile
 595         ) {
 596
 597             private record Contact(
 598                     String name, String color, int messageExpirationTime, boolean blocked, boolean archived
 599             ) {}
 600
 601             private record Profile(
 602                     long lastUpdateTimestamp,
 603                     String givenName,
 604                     String familyName,
 605                     String about,
 606                     String aboutEmoji,
 607                     String avatarUrlPath,
 608                     String unidentifiedAccessMode,
 609                     Set<String> capabilities
 610             ) {}
 611         }
 612     }
 613
 614     public interface RecipientMergeHandler {
 615
 616         void mergeRecipients(RecipientId recipientId, RecipientId toBeMergedRecipientId);
 617     }
 618 }