]> nmode's Git Repositories - signal-cli/blobdiff - lib/src/main/java/org/asamk/signal/manager/Manager.java
Rename group v2 helper
[signal-cli] / lib / src / main / java / org / asamk / signal / manager / Manager.java
index c1189df30477fcf512678383c34c76e99fbadff6..cd0ce561a4b9ce08edc0fb91fa4281ca35f87fc5 100644 (file)
@@ -16,6 +16,7 @@
  */
 package org.asamk.signal.manager;
 
+import org.asamk.signal.manager.api.Device;
 import org.asamk.signal.manager.config.ServiceConfig;
 import org.asamk.signal.manager.config.ServiceEnvironment;
 import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
@@ -25,19 +26,21 @@ import org.asamk.signal.manager.groups.GroupInviteLinkUrl;
 import org.asamk.signal.manager.groups.GroupNotFoundException;
 import org.asamk.signal.manager.groups.GroupUtils;
 import org.asamk.signal.manager.groups.NotAGroupMemberException;
-import org.asamk.signal.manager.helper.GroupHelper;
+import org.asamk.signal.manager.helper.GroupV2Helper;
 import org.asamk.signal.manager.helper.PinHelper;
 import org.asamk.signal.manager.helper.ProfileHelper;
 import org.asamk.signal.manager.helper.UnidentifiedAccessHelper;
 import org.asamk.signal.manager.storage.SignalAccount;
-import org.asamk.signal.manager.storage.contacts.ContactInfo;
 import org.asamk.signal.manager.storage.groups.GroupInfo;
 import org.asamk.signal.manager.storage.groups.GroupInfoV1;
 import org.asamk.signal.manager.storage.groups.GroupInfoV2;
+import org.asamk.signal.manager.storage.identities.IdentityInfo;
 import org.asamk.signal.manager.storage.messageCache.CachedMessage;
-import org.asamk.signal.manager.storage.profiles.SignalProfile;
-import org.asamk.signal.manager.storage.protocol.IdentityInfo;
+import org.asamk.signal.manager.storage.recipients.Contact;
+import org.asamk.signal.manager.storage.recipients.Profile;
+import org.asamk.signal.manager.storage.recipients.RecipientId;
 import org.asamk.signal.manager.storage.stickers.Sticker;
+import org.asamk.signal.manager.storage.stickers.StickerPackId;
 import org.asamk.signal.manager.util.AttachmentUtils;
 import org.asamk.signal.manager.util.IOUtils;
 import org.asamk.signal.manager.util.KeyUtils;
@@ -80,6 +83,7 @@ import org.whispersystems.signalservice.api.SignalServiceAccountManager;
 import org.whispersystems.signalservice.api.SignalServiceMessagePipe;
 import org.whispersystems.signalservice.api.SignalServiceMessageReceiver;
 import org.whispersystems.signalservice.api.SignalServiceMessageSender;
+import org.whispersystems.signalservice.api.SignalSessionLock;
 import org.whispersystems.signalservice.api.crypto.SignalServiceCipher;
 import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
 import org.whispersystems.signalservice.api.groupsv2.ClientZkOperations;
@@ -106,7 +110,6 @@ import org.whispersystems.signalservice.api.messages.multidevice.DeviceContactsO
 import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroup;
 import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroupsInputStream;
 import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroupsOutputStream;
-import org.whispersystems.signalservice.api.messages.multidevice.DeviceInfo;
 import org.whispersystems.signalservice.api.messages.multidevice.RequestMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.SentTranscriptMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
@@ -116,6 +119,8 @@ import org.whispersystems.signalservice.api.profiles.ProfileAndCredential;
 import org.whispersystems.signalservice.api.profiles.SignalServiceProfile;
 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
 import org.whispersystems.signalservice.api.push.exceptions.MissingConfigurationException;
+import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;
+import org.whispersystems.signalservice.api.util.DeviceNameUtil;
 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 import org.whispersystems.signalservice.api.util.PhoneNumberFormatter;
 import org.whispersystems.signalservice.api.util.SleepTimer;
@@ -145,6 +150,7 @@ import java.nio.file.Files;
 import java.security.SignatureException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Base64;
 import java.util.Collection;
 import java.util.Date;
 import java.util.HashSet;
@@ -156,6 +162,7 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -184,10 +191,19 @@ public class Manager implements Closeable {
 
     private final UnidentifiedAccessHelper unidentifiedAccessHelper;
     private final ProfileHelper profileHelper;
-    private final GroupHelper groupHelper;
+    private final GroupV2Helper groupV2Helper;
     private final PinHelper pinHelper;
     private final AvatarStore avatarStore;
     private final AttachmentStore attachmentStore;
+    private final SignalSessionLock sessionLock = new SignalSessionLock() {
+        private final ReentrantLock LEGACY_LOCK = new ReentrantLock();
+
+        @Override
+        public Lock acquire() {
+            LEGACY_LOCK.lock();
+            return LEGACY_LOCK::unlock;
+        }
+    };
 
     Manager(
             SignalAccount account,
@@ -234,8 +250,6 @@ public class Manager implements Closeable {
                 clientZkProfileOperations,
                 ServiceConfig.AUTOMATIC_NETWORK_RETRY);
 
-        this.account.setResolver(this::resolveSignalServiceAddress);
-
         this.unidentifiedAccessHelper = new UnidentifiedAccessHelper(account::getProfileKey,
                 account.getProfileStore()::getProfileKey,
                 this::getRecipientProfile,
@@ -243,13 +257,15 @@ public class Manager implements Closeable {
         this.profileHelper = new ProfileHelper(account.getProfileStore()::getProfileKey,
                 unidentifiedAccessHelper::getAccessFor,
                 unidentified -> unidentified ? getOrCreateUnidentifiedMessagePipe() : getOrCreateMessagePipe(),
-                () -> messageReceiver);
-        this.groupHelper = new GroupHelper(this::getRecipientProfileKeyCredential,
+                () -> messageReceiver,
+                this::resolveSignalServiceAddress);
+        this.groupV2Helper = new GroupV2Helper(this::getRecipientProfileKeyCredential,
                 this::getRecipientProfile,
-                account::getSelfAddress,
+                account::getSelfRecipientId,
                 groupsV2Operations,
                 groupsV2Api,
-                this::getGroupAuthForToday);
+                this::getGroupAuthForToday,
+                this::resolveSignalServiceAddress);
         this.avatarStore = new AvatarStore(pathConfig.getAvatarsPath());
         this.attachmentStore = new AttachmentStore(pathConfig.getAttachmentsPath());
     }
@@ -262,6 +278,10 @@ public class Manager implements Closeable {
         return account.getSelfAddress();
     }
 
+    public RecipientId getSelfRecipientId() {
+        return account.getSelfRecipientId();
+    }
+
     private IdentityKeyPair getIdentityKeyPair() {
         return account.getIdentityKeyPair();
     }
@@ -279,7 +299,7 @@ public class Manager implements Closeable {
             throw new NotRegisteredException();
         }
 
-        var account = SignalAccount.load(pathConfig.getDataPath(), username);
+        var account = SignalAccount.load(pathConfig.getDataPath(), username, true);
 
         if (!account.isRegistered()) {
             throw new NotRegisteredException();
@@ -309,11 +329,9 @@ public class Manager implements Closeable {
     public void checkAccountState() throws IOException {
         if (accountManager.getPreKeysCount() < ServiceConfig.PREKEY_MINIMUM_COUNT) {
             refreshPreKeys();
-            account.save();
         }
         if (account.getUuid() == null) {
             account.setUuid(accountManager.getOwnUuid());
-            account.save();
         }
         updateAccountAttributes();
     }
@@ -335,7 +353,8 @@ public class Manager implements Closeable {
     }
 
     public void updateAccountAttributes() throws IOException {
-        accountManager.setAccountAttributes(null,
+        accountManager.setAccountAttributes(account.getEncryptedDeviceName(),
+                null,
                 account.getLocalRegistrationId(),
                 true,
                 // set legacy pin only if no KBS master key is set
@@ -348,33 +367,40 @@ public class Manager implements Closeable {
     }
 
     /**
-     * @param name       if null, the previous name will be kept
+     * @param givenName  if null, the previous givenName will be kept
+     * @param familyName if null, the previous familyName will be kept
      * @param about      if null, the previous about text will be kept
      * @param aboutEmoji if null, the previous about emoji will be kept
      * @param avatar     if avatar is null the image from the local avatar store is used (if present),
-     *                   if it's Optional.absent(), the avatar will be removed
      */
-    public void setProfile(String name, String about, String aboutEmoji, Optional<File> avatar) throws IOException {
-        var profileEntry = account.getProfileStore().getProfileEntry(getSelfAddress());
-        var profile = profileEntry == null ? null : profileEntry.getProfile();
-        var newProfile = new SignalProfile(profile == null ? null : profile.getIdentityKey(),
-                name != null ? name : profile == null || profile.getName() == null ? "" : profile.getName(),
-                about != null ? about : profile == null || profile.getAbout() == null ? "" : profile.getAbout(),
-                aboutEmoji != null
-                        ? aboutEmoji
-                        : profile == null || profile.getAboutEmoji() == null ? "" : profile.getAboutEmoji(),
-                profile == null ? null : profile.getUnidentifiedAccess(),
-                account.isUnrestrictedUnidentifiedAccess(),
-                profile == null ? null : profile.getCapabilities());
+    public void setProfile(
+            String givenName, final String familyName, String about, String aboutEmoji, Optional<File> avatar
+    ) throws IOException {
+        var profile = getRecipientProfile(account.getSelfRecipientId());
+        var builder = profile == null ? Profile.newBuilder() : Profile.newBuilder(profile);
+        if (givenName != null) {
+            builder.withGivenName(givenName);
+        }
+        if (familyName != null) {
+            builder.withFamilyName(familyName);
+        }
+        if (about != null) {
+            builder.withAbout(about);
+        }
+        if (aboutEmoji != null) {
+            builder.withAboutEmoji(aboutEmoji);
+        }
+        var newProfile = builder.build();
 
         try (final var streamDetails = avatar == null
                 ? avatarStore.retrieveProfileAvatar(getSelfAddress())
                 : avatar.isPresent() ? Utils.createStreamDetailsFromFile(avatar.get()) : null) {
             accountManager.setVersionedProfile(account.getUuid(),
                     account.getProfileKey(),
-                    newProfile.getName(),
-                    newProfile.getAbout(),
-                    newProfile.getAboutEmoji(),
+                    newProfile.getInternalServiceName(),
+                    newProfile.getAbout() == null ? "" : newProfile.getAbout(),
+                    newProfile.getAboutEmoji() == null ? "" : newProfile.getAboutEmoji(),
+                    Optional.absent(),
                     streamDetails);
         }
 
@@ -386,12 +412,7 @@ public class Manager implements Closeable {
                 avatarStore.deleteProfileAvatar(getSelfAddress());
             }
         }
-        account.getProfileStore()
-                .updateProfile(getSelfAddress(),
-                        account.getProfileKey(),
-                        System.currentTimeMillis(),
-                        newProfile,
-                        profileEntry == null ? null : profileEntry.getProfileKeyCredential());
+        account.getProfileStore().storeProfile(account.getSelfRecipientId(), newProfile);
 
         try {
             sendSyncMessage(SignalServiceSyncMessage.forFetchLatest(SignalServiceSyncMessage.FetchType.LOCAL_PROFILE));
@@ -404,24 +425,37 @@ public class Manager implements Closeable {
         // If this is the master device, other users can't send messages to this number anymore.
         // If this is a linked device, other users can still send messages, but this device doesn't receive them anymore.
         accountManager.setGcmId(Optional.absent());
+
+        account.setRegistered(false);
+    }
+
+    public void deleteAccount() throws IOException {
         accountManager.deleteAccount();
 
         account.setRegistered(false);
-        account.save();
     }
 
-    public List<DeviceInfo> getLinkedDevices() throws IOException {
+    public List<Device> getLinkedDevices() throws IOException {
         var devices = accountManager.getDevices();
         account.setMultiDevice(devices.size() > 1);
-        account.save();
-        return devices;
+        var identityKey = account.getIdentityKeyPair().getPrivateKey();
+        return devices.stream().map(d -> {
+            String deviceName = d.getName();
+            if (deviceName != null) {
+                try {
+                    deviceName = DeviceNameUtil.decryptDeviceName(deviceName, identityKey);
+                } catch (IOException e) {
+                    logger.debug("Failed to decrypt device name, maybe plain text?", e);
+                }
+            }
+            return new Device(d.getId(), deviceName, d.getCreated(), d.getLastSeen());
+        }).collect(Collectors.toList());
     }
 
     public void removeLinkedDevices(int deviceId) throws IOException {
         accountManager.removeDevice(deviceId);
         var devices = accountManager.getDevices();
         account.setMultiDevice(devices.size() > 1);
-        account.save();
     }
 
     public void addDeviceLink(URI linkUri) throws IOException, InvalidKeyException {
@@ -440,7 +474,6 @@ public class Manager implements Closeable {
                 Optional.of(account.getProfileKey().serialize()),
                 verificationCode);
         account.setMultiDevice(true);
-        account.save();
     }
 
     public void setRegistrationLockPin(Optional<String> pin) throws IOException, UnauthenticatedResponseException {
@@ -454,8 +487,7 @@ public class Manager implements Closeable {
 
             pinHelper.setRegistrationLockPin(pin.get(), masterKey);
 
-            account.setRegistrationLockPin(pin.get());
-            account.setPinMasterKey(masterKey);
+            account.setRegistrationLockPin(pin.get(), masterKey);
         } else {
             // Remove legacy registration lock
             accountManager.removeRegistrationLockV1();
@@ -463,10 +495,8 @@ public class Manager implements Closeable {
             // Remove KBS Pin
             pinHelper.removeRegistrationLockPin();
 
-            account.setRegistrationLockPin(null);
-            account.setPinMasterKey(null);
+            account.setRegistrationLockPin(null, null);
         }
-        account.save();
     }
 
     void refreshPreKeys() throws IOException {
@@ -516,6 +546,7 @@ public class Manager implements Closeable {
                 account.getPassword(),
                 account.getDeviceId(),
                 account.getSignalProtocolStore(),
+                sessionLock,
                 userAgent,
                 account.isMultiDevice(),
                 Optional.fromNullable(messagePipe),
@@ -527,79 +558,125 @@ public class Manager implements Closeable {
                 ServiceConfig.AUTOMATIC_NETWORK_RETRY);
     }
 
-    public SignalProfile getRecipientProfile(
-            SignalServiceAddress address
+    public Profile getRecipientProfile(
+            RecipientId recipientId
     ) {
-        return getRecipientProfile(address, false);
+        return getRecipientProfile(recipientId, false);
     }
 
-    private SignalProfile getRecipientProfile(
-            SignalServiceAddress address, boolean force
+    private final Set<RecipientId> pendingProfileRequest = new HashSet<>();
+
+    Profile getRecipientProfile(
+            RecipientId recipientId, boolean force
     ) {
-        var profileEntry = account.getProfileStore().getProfileEntry(address);
-        if (profileEntry == null) {
-            return null;
-        }
+        var profile = account.getProfileStore().getProfile(recipientId);
+
         var now = new Date().getTime();
-        // Profiles are cached for 24h before retrieving them again
-        if (!profileEntry.isRequestPending() && (
-                force
-                        || profileEntry.getProfile() == null
-                        || now - profileEntry.getLastUpdateTimestamp() > 24 * 60 * 60 * 1000
-        )) {
-            profileEntry.setRequestPending(true);
-            final SignalServiceProfile encryptedProfile;
-            try {
-                encryptedProfile = profileHelper.retrieveProfileSync(address, SignalServiceProfile.RequestType.PROFILE)
-                        .getProfile();
-            } catch (IOException e) {
-                logger.warn("Failed to retrieve profile, ignoring: {}", e.getMessage());
-                return null;
-            } finally {
-                profileEntry.setRequestPending(false);
+        // Profiles are cached for 24h before retrieving them again, unless forced
+        if (!force && profile != null && now - profile.getLastUpdateTimestamp() < 24 * 60 * 60 * 1000) {
+            return profile;
+        }
+
+        synchronized (pendingProfileRequest) {
+            if (pendingProfileRequest.contains(recipientId)) {
+                return profile;
+            }
+            pendingProfileRequest.add(recipientId);
+        }
+        final SignalServiceProfile encryptedProfile;
+        try {
+            encryptedProfile = retrieveEncryptedProfile(recipientId);
+        } finally {
+            synchronized (pendingProfileRequest) {
+                pendingProfileRequest.remove(recipientId);
             }
+        }
+        if (encryptedProfile == null) {
+            return null;
+        }
 
-            final var profileKey = profileEntry.getProfileKey();
-            final var profile = decryptProfileAndDownloadAvatar(address, profileKey, encryptedProfile);
-            account.getProfileStore()
-                    .updateProfile(address, profileKey, now, profile, profileEntry.getProfileKeyCredential());
-            return profile;
+        var profileKey = account.getProfileStore().getProfileKey(recipientId);
+        if (profileKey == null) {
+            profile = new Profile(new Date().getTime(),
+                    null,
+                    null,
+                    null,
+                    null,
+                    ProfileUtils.getUnidentifiedAccessMode(encryptedProfile, null),
+                    ProfileUtils.getCapabilities(encryptedProfile));
+        } else {
+            profile = decryptProfileAndDownloadAvatar(recipientId, profileKey, encryptedProfile);
         }
-        return profileEntry.getProfile();
+        account.getProfileStore().storeProfile(recipientId, profile);
+
+        return profile;
     }
 
-    private ProfileKeyCredential getRecipientProfileKeyCredential(SignalServiceAddress address) {
-        var profileEntry = account.getProfileStore().getProfileEntry(address);
-        if (profileEntry == null) {
+    private SignalServiceProfile retrieveEncryptedProfile(RecipientId recipientId) {
+        try {
+            return retrieveProfileAndCredential(recipientId, SignalServiceProfile.RequestType.PROFILE).getProfile();
+        } catch (IOException e) {
+            logger.warn("Failed to retrieve profile, ignoring: {}", e.getMessage());
             return null;
         }
-        if (profileEntry.getProfileKeyCredential() == null) {
-            ProfileAndCredential profileAndCredential;
-            try {
-                profileAndCredential = profileHelper.retrieveProfileSync(address,
-                        SignalServiceProfile.RequestType.PROFILE_AND_CREDENTIAL);
-            } catch (IOException e) {
-                logger.warn("Failed to retrieve profile key credential, ignoring: {}", e.getMessage());
-                return null;
+    }
+
+    private ProfileAndCredential retrieveProfileAndCredential(
+            final RecipientId recipientId, final SignalServiceProfile.RequestType requestType
+    ) throws IOException {
+        final var profileAndCredential = profileHelper.retrieveProfileSync(recipientId, requestType);
+        final var profile = profileAndCredential.getProfile();
+
+        try {
+            var newIdentity = account.getIdentityKeyStore()
+                    .saveIdentity(recipientId,
+                            new IdentityKey(Base64.getDecoder().decode(profile.getIdentityKey())),
+                            new Date());
+
+            if (newIdentity) {
+                account.getSessionStore().archiveSessions(recipientId);
             }
+        } catch (InvalidKeyException ignored) {
+            logger.warn("Got invalid identity key in profile for {}",
+                    resolveSignalServiceAddress(recipientId).getLegacyIdentifier());
+        }
+        return profileAndCredential;
+    }
 
-            var now = new Date().getTime();
-            final var profileKeyCredential = profileAndCredential.getProfileKeyCredential().orNull();
-            final var profile = decryptProfileAndDownloadAvatar(address,
-                    profileEntry.getProfileKey(),
-                    profileAndCredential.getProfile());
-            account.getProfileStore()
-                    .updateProfile(address, profileEntry.getProfileKey(), now, profile, profileKeyCredential);
+    private ProfileKeyCredential getRecipientProfileKeyCredential(RecipientId recipientId) {
+        var profileKeyCredential = account.getProfileStore().getProfileKeyCredential(recipientId);
+        if (profileKeyCredential != null) {
             return profileKeyCredential;
         }
-        return profileEntry.getProfileKeyCredential();
+
+        ProfileAndCredential profileAndCredential;
+        try {
+            profileAndCredential = retrieveProfileAndCredential(recipientId,
+                    SignalServiceProfile.RequestType.PROFILE_AND_CREDENTIAL);
+        } catch (IOException e) {
+            logger.warn("Failed to retrieve profile key credential, ignoring: {}", e.getMessage());
+            return null;
+        }
+
+        profileKeyCredential = profileAndCredential.getProfileKeyCredential().orNull();
+        account.getProfileStore().storeProfileKeyCredential(recipientId, profileKeyCredential);
+
+        var profileKey = account.getProfileStore().getProfileKey(recipientId);
+        if (profileKey != null) {
+            final var profile = decryptProfileAndDownloadAvatar(recipientId,
+                    profileKey,
+                    profileAndCredential.getProfile());
+            account.getProfileStore().storeProfile(recipientId, profile);
+        }
+
+        return profileKeyCredential;
     }
 
-    private SignalProfile decryptProfileAndDownloadAvatar(
-            final SignalServiceAddress address, final ProfileKey profileKey, final SignalServiceProfile encryptedProfile
+    private Profile decryptProfileAndDownloadAvatar(
+            final RecipientId recipientId, final ProfileKey profileKey, final SignalServiceProfile encryptedProfile
     ) {
         if (encryptedProfile.getAvatar() != null) {
-            downloadProfileAvatar(address, encryptedProfile.getAvatar(), profileKey);
+            downloadProfileAvatar(resolveSignalServiceAddress(recipientId), encryptedProfile.getAvatar(), profileKey);
         }
 
         return ProfileUtils.decryptProfile(profileKey, encryptedProfile);
@@ -628,7 +705,7 @@ public class Manager implements Closeable {
         if (g == null) {
             throw new GroupNotFoundException(groupId);
         }
-        if (!g.isMember(account.getSelfAddress())) {
+        if (!g.isMember(account.getSelfRecipientId())) {
             throw new NotAGroupMemberException(groupId, g.getTitle());
         }
         return g;
@@ -639,7 +716,7 @@ public class Manager implements Closeable {
         if (g == null) {
             throw new GroupNotFoundException(groupId);
         }
-        if (!g.isMember(account.getSelfAddress()) && !g.isPendingMember(account.getSelfAddress())) {
+        if (!g.isMember(account.getSelfRecipientId()) && !g.isPendingMember(account.getSelfRecipientId())) {
             throw new NotAGroupMemberException(groupId, g.getTitle());
         }
         return g;
@@ -663,9 +740,10 @@ public class Manager implements Closeable {
     public Pair<Long, List<SendMessageResult>> sendGroupMessageReaction(
             String emoji, boolean remove, String targetAuthor, long targetSentTimestamp, GroupId groupId
     ) throws IOException, InvalidNumberException, NotAGroupMemberException, GroupNotFoundException {
+        var targetAuthorRecipientId = canonicalizeAndResolveRecipient(targetAuthor);
         var reaction = new SignalServiceDataMessage.Reaction(emoji,
                 remove,
-                canonicalizeAndResolveSignalServiceAddress(targetAuthor),
+                resolveSignalServiceAddress(targetAuthorRecipientId),
                 targetSentTimestamp);
         final var messageBuilder = SignalServiceDataMessage.newBuilder().withReaction(reaction);
 
@@ -680,7 +758,7 @@ public class Manager implements Closeable {
         GroupUtils.setGroupContext(messageBuilder, g);
         messageBuilder.withExpiration(g.getMessageExpirationTime());
 
-        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfRecipientId()));
     }
 
     public Pair<Long, List<SendMessageResult>> sendQuitGroupMessage(GroupId groupId) throws GroupNotFoundException, IOException, NotAGroupMemberException {
@@ -691,118 +769,121 @@ public class Manager implements Closeable {
             var groupInfoV1 = (GroupInfoV1) g;
             var group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT).withId(groupId.serialize()).build();
             messageBuilder = SignalServiceDataMessage.newBuilder().asGroupMessage(group);
-            groupInfoV1.removeMember(account.getSelfAddress());
+            groupInfoV1.removeMember(account.getSelfRecipientId());
             account.getGroupStore().updateGroup(groupInfoV1);
         } else {
             final var groupInfoV2 = (GroupInfoV2) g;
-            final var groupGroupChangePair = groupHelper.leaveGroup(groupInfoV2);
-            groupInfoV2.setGroup(groupGroupChangePair.first());
+            final var groupGroupChangePair = groupV2Helper.leaveGroup(groupInfoV2);
+            groupInfoV2.setGroup(groupGroupChangePair.first(), this::resolveRecipient);
             messageBuilder = getGroupUpdateMessageBuilder(groupInfoV2, groupGroupChangePair.second().toByteArray());
             account.getGroupStore().updateGroup(groupInfoV2);
         }
 
-        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfRecipientId()));
+    }
+
+    public Pair<GroupId, List<SendMessageResult>> createGroup(
+            String name, List<String> members, File avatarFile
+    ) throws IOException, AttachmentInvalidException, InvalidNumberException {
+        return createGroup(name, members == null ? null : getSignalServiceAddresses(members), avatarFile);
+    }
+
+    private Pair<GroupId, List<SendMessageResult>> createGroup(
+            String name, Set<RecipientId> members, File avatarFile
+    ) throws IOException, AttachmentInvalidException {
+        final var selfRecipientId = account.getSelfRecipientId();
+        if (members != null && members.contains(selfRecipientId)) {
+            members = new HashSet<>(members);
+            members.remove(selfRecipientId);
+        }
+
+        var gv2Pair = groupV2Helper.createGroup(name == null ? "" : name,
+                members == null ? Set.of() : members,
+                avatarFile);
+
+        SignalServiceDataMessage.Builder messageBuilder;
+        if (gv2Pair == null) {
+            // Failed to create v2 group, creating v1 group instead
+            var gv1 = new GroupInfoV1(GroupIdV1.createRandom());
+            gv1.addMembers(List.of(selfRecipientId));
+            final var result = updateGroupV1(gv1, name, members, avatarFile);
+            return new Pair<>(gv1.getGroupId(), result.second());
+        }
+
+        final var gv2 = gv2Pair.first();
+        final var decryptedGroup = gv2Pair.second();
+
+        gv2.setGroup(decryptedGroup, this::resolveRecipient);
+        if (avatarFile != null) {
+            avatarStore.storeGroupAvatar(gv2.getGroupId(),
+                    outputStream -> IOUtils.copyFileToStream(avatarFile, outputStream));
+        }
+        messageBuilder = getGroupUpdateMessageBuilder(gv2, null);
+        account.getGroupStore().updateGroup(gv2);
+
+        final var result = sendMessage(messageBuilder, gv2.getMembersIncludingPendingWithout(selfRecipientId));
+        return new Pair<>(gv2.getGroupId(), result.second());
     }
 
-    public Pair<GroupId, List<SendMessageResult>> updateGroup(
-            GroupId groupId, String name, List<String> members, File avatarFile
+    public Pair<Long, List<SendMessageResult>> updateGroup(
+            GroupId groupId,
+            String name,
+            String description,
+            List<String> members,
+            List<String> removeMembers,
+            File avatarFile
     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException {
-        return sendUpdateGroupMessage(groupId,
+        return updateGroup(groupId,
                 name,
+                description,
                 members == null ? null : getSignalServiceAddresses(members),
+                removeMembers == null ? null : getSignalServiceAddresses(removeMembers),
                 avatarFile);
     }
 
-    private Pair<GroupId, List<SendMessageResult>> sendUpdateGroupMessage(
-            GroupId groupId, String name, Collection<SignalServiceAddress> members, File avatarFile
+    private Pair<Long, List<SendMessageResult>> updateGroup(
+            GroupId groupId,
+            String name,
+            String description,
+            Set<RecipientId> members,
+            final Set<RecipientId> removeMembers,
+            File avatarFile
     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
-        GroupInfo g;
-        SignalServiceDataMessage.Builder messageBuilder;
-        if (groupId == null) {
-            // Create new group
-            var gv2 = groupHelper.createGroupV2(name == null ? "" : name,
-                    members == null ? List.of() : members,
-                    avatarFile);
-            if (gv2 == null) {
-                var gv1 = new GroupInfoV1(GroupIdV1.createRandom());
-                gv1.addMembers(List.of(account.getSelfAddress()));
-                updateGroupV1(gv1, name, members, avatarFile);
-                messageBuilder = getGroupUpdateMessageBuilder(gv1);
-                g = gv1;
-            } else {
-                if (avatarFile != null) {
-                    avatarStore.storeGroupAvatar(gv2.getGroupId(),
-                            outputStream -> IOUtils.copyFileToStream(avatarFile, outputStream));
-                }
-                messageBuilder = getGroupUpdateMessageBuilder(gv2, null);
-                g = gv2;
-            }
-        } else {
-            var group = getGroupForUpdating(groupId);
-            if (group instanceof GroupInfoV2) {
-                final var groupInfoV2 = (GroupInfoV2) group;
-
-                Pair<Long, List<SendMessageResult>> result = null;
-                if (groupInfoV2.isPendingMember(getSelfAddress())) {
-                    var groupGroupChangePair = groupHelper.acceptInvite(groupInfoV2);
-                    result = sendUpdateGroupMessage(groupInfoV2,
-                            groupGroupChangePair.first(),
-                            groupGroupChangePair.second());
-                }
+        var group = getGroupForUpdating(groupId);
 
-                if (members != null) {
-                    final var newMembers = new HashSet<>(members);
-                    newMembers.removeAll(group.getMembers()
-                            .stream()
-                            .map(this::resolveSignalServiceAddress)
-                            .collect(Collectors.toSet()));
-                    if (newMembers.size() > 0) {
-                        var groupGroupChangePair = groupHelper.updateGroupV2(groupInfoV2, newMembers);
-                        result = sendUpdateGroupMessage(groupInfoV2,
-                                groupGroupChangePair.first(),
-                                groupGroupChangePair.second());
-                    }
-                }
-                if (result == null || name != null || avatarFile != null) {
-                    var groupGroupChangePair = groupHelper.updateGroupV2(groupInfoV2, name, avatarFile);
-                    if (avatarFile != null) {
-                        avatarStore.storeGroupAvatar(groupInfoV2.getGroupId(),
-                                outputStream -> IOUtils.copyFileToStream(avatarFile, outputStream));
-                    }
-                    result = sendUpdateGroupMessage(groupInfoV2,
-                            groupGroupChangePair.first(),
-                            groupGroupChangePair.second());
-                }
-
-                return new Pair<>(group.getGroupId(), result.second());
-            } else {
-                var gv1 = (GroupInfoV1) group;
-                updateGroupV1(gv1, name, members, avatarFile);
-                messageBuilder = getGroupUpdateMessageBuilder(gv1);
-                g = gv1;
-            }
+        if (group instanceof GroupInfoV2) {
+            return updateGroupV2((GroupInfoV2) group, name, description, members, removeMembers, avatarFile);
         }
 
-        account.getGroupStore().updateGroup(g);
+        return updateGroupV1((GroupInfoV1) group, name, members, avatarFile);
+    }
+
+    private Pair<Long, List<SendMessageResult>> updateGroupV1(
+            final GroupInfoV1 gv1, final String name, final Set<RecipientId> members, final File avatarFile
+    ) throws IOException, AttachmentInvalidException {
+        updateGroupV1Details(gv1, name, members, avatarFile);
+        var messageBuilder = getGroupUpdateMessageBuilder(gv1);
+
+        account.getGroupStore().updateGroup(gv1);
 
-        final var result = sendMessage(messageBuilder, g.getMembersIncludingPendingWithout(account.getSelfAddress()));
-        return new Pair<>(g.getGroupId(), result.second());
+        return sendMessage(messageBuilder, gv1.getMembersIncludingPendingWithout(account.getSelfRecipientId()));
     }
 
-    private void updateGroupV1(
-            final GroupInfoV1 g,
-            final String name,
-            final Collection<SignalServiceAddress> members,
-            final File avatarFile
+    private void updateGroupV1Details(
+            final GroupInfoV1 g, final String name, final Collection<RecipientId> members, final File avatarFile
     ) throws IOException {
         if (name != null) {
             g.name = name;
         }
 
         if (members != null) {
+            final var newMemberAddresses = members.stream()
+                    .filter(member -> !g.isMember(member))
+                    .map(this::resolveSignalServiceAddress)
+                    .collect(Collectors.toList());
             final var newE164Members = new HashSet<String>();
-            for (var member : members) {
-                if (g.isMember(member) || !member.getNumber().isPresent()) {
+            for (var member : newMemberAddresses) {
+                if (!member.getNumber().isPresent()) {
                     continue;
                 }
                 newE164Members.add(member.getNumber().get());
@@ -826,18 +907,64 @@ public class Manager implements Closeable {
         }
     }
 
-    public Pair<GroupId, List<SendMessageResult>> joinGroup(
-            GroupInviteLinkUrl inviteLinkUrl
-    ) throws IOException, GroupLinkNotActiveException {
-        return sendJoinGroupMessage(inviteLinkUrl);
+    private Pair<Long, List<SendMessageResult>> updateGroupV2(
+            final GroupInfoV2 group,
+            final String name,
+            final String description,
+            final Set<RecipientId> members,
+            final Set<RecipientId> removeMembers,
+            final File avatarFile
+    ) throws IOException {
+        Pair<Long, List<SendMessageResult>> result = null;
+        if (group.isPendingMember(account.getSelfRecipientId())) {
+            var groupGroupChangePair = groupV2Helper.acceptInvite(group);
+            result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+        }
+
+        if (members != null) {
+            final var newMembers = new HashSet<>(members);
+            newMembers.removeAll(group.getMembers());
+            if (newMembers.size() > 0) {
+                var groupGroupChangePair = groupV2Helper.addMembers(group, newMembers);
+                result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+            }
+        }
+
+        if (removeMembers != null) {
+            var existingRemoveMembers = new HashSet<>(removeMembers);
+            existingRemoveMembers.retainAll(group.getMembers());
+            existingRemoveMembers.remove(getSelfRecipientId());// self can be removed with sendQuitGroupMessage
+            if (existingRemoveMembers.size() > 0) {
+                var groupGroupChangePair = groupV2Helper.removeMembers(group, existingRemoveMembers);
+                result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+            }
+
+            var pendingRemoveMembers = new HashSet<>(removeMembers);
+            pendingRemoveMembers.retainAll(group.getPendingMembers());
+            if (pendingRemoveMembers.size() > 0) {
+                var groupGroupChangePair = groupV2Helper.revokeInvitedMembers(group, pendingRemoveMembers);
+                result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+            }
+        }
+
+        if (result == null || name != null || description != null || avatarFile != null) {
+            var groupGroupChangePair = groupV2Helper.updateGroup(group, name, description, avatarFile);
+            if (avatarFile != null) {
+                avatarStore.storeGroupAvatar(group.getGroupId(),
+                        outputStream -> IOUtils.copyFileToStream(avatarFile, outputStream));
+            }
+            result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+        }
+
+        return result;
     }
 
-    private Pair<GroupId, List<SendMessageResult>> sendJoinGroupMessage(
+    public Pair<GroupId, List<SendMessageResult>> joinGroup(
             GroupInviteLinkUrl inviteLinkUrl
     ) throws IOException, GroupLinkNotActiveException {
-        final var groupJoinInfo = groupHelper.getDecryptedGroupJoinInfo(inviteLinkUrl.getGroupMasterKey(),
+        final var groupJoinInfo = groupV2Helper.getDecryptedGroupJoinInfo(inviteLinkUrl.getGroupMasterKey(),
                 inviteLinkUrl.getPassword());
-        final var groupChange = groupHelper.joinGroup(inviteLinkUrl.getGroupMasterKey(),
+        final var groupChange = groupV2Helper.joinGroup(inviteLinkUrl.getGroupMasterKey(),
                 inviteLinkUrl.getPassword(),
                 groupJoinInfo);
         final var group = getOrMigrateGroup(inviteLinkUrl.getGroupMasterKey(),
@@ -849,11 +976,24 @@ public class Manager implements Closeable {
             return new Pair<>(group.getGroupId(), List.of());
         }
 
-        final var result = sendUpdateGroupMessage(group, group.getGroup(), groupChange);
+        final var result = sendUpdateGroupV2Message(group, group.getGroup(), groupChange);
 
         return new Pair<>(group.getGroupId(), result.second());
     }
 
+    private Pair<Long, List<SendMessageResult>> sendUpdateGroupV2Message(
+            GroupInfoV2 group, DecryptedGroup newDecryptedGroup, GroupChange groupChange
+    ) throws IOException {
+        final var selfRecipientId = account.getSelfRecipientId();
+        final var members = group.getMembersIncludingPendingWithout(selfRecipientId);
+        group.setGroup(newDecryptedGroup, this::resolveRecipient);
+        members.addAll(group.getMembersIncludingPendingWithout(selfRecipientId));
+
+        final var messageBuilder = getGroupUpdateMessageBuilder(group, groupChange.toByteArray());
+        account.getGroupStore().updateGroup(group);
+        return sendMessage(messageBuilder, members);
+    }
+
     private static int currentTimeDays() {
         return (int) TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
     }
@@ -876,15 +1016,6 @@ public class Manager implements Closeable {
         }
     }
 
-    private Pair<Long, List<SendMessageResult>> sendUpdateGroupMessage(
-            GroupInfoV2 group, DecryptedGroup newDecryptedGroup, GroupChange groupChange
-    ) throws IOException {
-        group.setGroup(newDecryptedGroup);
-        final var messageBuilder = getGroupUpdateMessageBuilder(group, groupChange.toByteArray());
-        account.getGroupStore().updateGroup(group);
-        return sendMessage(messageBuilder, group.getMembersIncludingPendingWithout(account.getSelfAddress()));
-    }
-
     Pair<Long, List<SendMessageResult>> sendGroupInfoMessage(
             GroupIdV1 groupId, SignalServiceAddress recipient
     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException {
@@ -895,21 +1026,25 @@ public class Manager implements Closeable {
         }
         g = (GroupInfoV1) group;
 
-        if (!g.isMember(recipient)) {
+        final var recipientId = resolveRecipient(recipient);
+        if (!g.isMember(recipientId)) {
             throw new NotAGroupMemberException(groupId, g.name);
         }
 
         var messageBuilder = getGroupUpdateMessageBuilder(g);
 
         // Send group message only to the recipient who requested it
-        return sendMessage(messageBuilder, List.of(recipient));
+        return sendMessage(messageBuilder, Set.of(recipientId));
     }
 
     private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfoV1 g) throws AttachmentInvalidException {
         var group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.UPDATE)
                 .withId(g.getGroupId().serialize())
                 .withName(g.name)
-                .withMembers(new ArrayList<>(g.getMembers()));
+                .withMembers(g.getMembers()
+                        .stream()
+                        .map(this::resolveSignalServiceAddress)
+                        .collect(Collectors.toList()));
 
         try {
             final var attachment = createGroupAvatarAttachment(g.getGroupId());
@@ -942,7 +1077,7 @@ public class Manager implements Closeable {
         var messageBuilder = SignalServiceDataMessage.newBuilder().asGroupMessage(group.build());
 
         // Send group info request message to the recipient who sent us a message with this groupId
-        return sendMessage(messageBuilder, List.of(recipient));
+        return sendMessage(messageBuilder, Set.of(resolveRecipient(recipient)));
     }
 
     void sendReceipt(
@@ -953,7 +1088,7 @@ public class Manager implements Closeable {
                 System.currentTimeMillis());
 
         createMessageSender().sendReceipt(remoteAddress,
-                unidentifiedAccessHelper.getAccessFor(remoteAddress),
+                unidentifiedAccessHelper.getAccessFor(resolveRecipient(remoteAddress)),
                 receiptMessage);
     }
 
@@ -1009,9 +1144,10 @@ public class Manager implements Closeable {
     public Pair<Long, List<SendMessageResult>> sendMessageReaction(
             String emoji, boolean remove, String targetAuthor, long targetSentTimestamp, List<String> recipients
     ) throws IOException, InvalidNumberException {
+        var targetAuthorRecipientId = canonicalizeAndResolveRecipient(targetAuthor);
         var reaction = new SignalServiceDataMessage.Reaction(emoji,
                 remove,
-                canonicalizeAndResolveSignalServiceAddress(targetAuthor),
+                resolveSignalServiceAddress(targetAuthorRecipientId),
                 targetSentTimestamp);
         final var messageBuilder = SignalServiceDataMessage.newBuilder().withReaction(reaction);
         return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));
@@ -1027,43 +1163,45 @@ public class Manager implements Closeable {
             for (var address : signalServiceAddresses) {
                 handleEndSession(address);
             }
-            account.save();
             throw e;
         }
     }
 
-    public String getContactName(String number) throws InvalidNumberException {
-        var contact = account.getContactStore().getContact(canonicalizeAndResolveSignalServiceAddress(number));
-        if (contact == null) {
-            return "";
-        } else {
-            return contact.name;
+    void renewSession(RecipientId recipientId) throws IOException {
+        account.getSessionStore().archiveSessions(recipientId);
+        if (!recipientId.equals(getSelfRecipientId())) {
+            sendNullMessage(recipientId);
         }
     }
 
-    public void setContactName(String number, String name) throws InvalidNumberException {
-        final var address = canonicalizeAndResolveSignalServiceAddress(number);
-        var contact = account.getContactStore().getContact(address);
-        if (contact == null) {
-            contact = new ContactInfo(address);
-        }
-        contact.name = name;
-        account.getContactStore().updateContact(contact);
-        account.save();
+    public String getContactName(String number) throws InvalidNumberException {
+        var contact = account.getContactStore().getContact(canonicalizeAndResolveRecipient(number));
+        return contact == null || contact.getName() == null ? "" : contact.getName();
     }
 
-    public void setContactBlocked(String number, boolean blocked) throws InvalidNumberException {
-        setContactBlocked(canonicalizeAndResolveSignalServiceAddress(number), blocked);
+    public void setContactName(String number, String name) throws InvalidNumberException, NotMasterDeviceException {
+        if (!account.isMasterDevice()) {
+            throw new NotMasterDeviceException();
+        }
+        final var recipientId = canonicalizeAndResolveRecipient(number);
+        var contact = account.getContactStore().getContact(recipientId);
+        final var builder = contact == null ? Contact.newBuilder() : Contact.newBuilder(contact);
+        account.getContactStore().storeContact(recipientId, builder.withName(name).build());
     }
 
-    private void setContactBlocked(SignalServiceAddress address, boolean blocked) {
-        var contact = account.getContactStore().getContact(address);
-        if (contact == null) {
-            contact = new ContactInfo(address);
+    public void setContactBlocked(
+            String number, boolean blocked
+    ) throws InvalidNumberException, NotMasterDeviceException {
+        if (!account.isMasterDevice()) {
+            throw new NotMasterDeviceException();
         }
-        contact.blocked = blocked;
-        account.getContactStore().updateContact(contact);
-        account.save();
+        setContactBlocked(canonicalizeAndResolveRecipient(number), blocked);
+    }
+
+    private void setContactBlocked(RecipientId recipientId, boolean blocked) {
+        var contact = account.getContactStore().getContact(recipientId);
+        final var builder = contact == null ? Contact.newBuilder() : Contact.newBuilder(contact);
+        account.getContactStore().storeContact(recipientId, builder.withBlocked(blocked).build());
     }
 
     public void setGroupBlocked(final GroupId groupId, final boolean blocked) throws GroupNotFoundException {
@@ -1074,23 +1212,21 @@ public class Manager implements Closeable {
 
         group.setBlocked(blocked);
         account.getGroupStore().updateGroup(group);
-        account.save();
     }
 
-    /**
-     * Change the expiration timer for a contact
-     */
-    public void setExpirationTimer(SignalServiceAddress address, int messageExpirationTimer) throws IOException {
-        var contact = account.getContactStore().getContact(address);
-        contact.messageExpirationTime = messageExpirationTimer;
-        account.getContactStore().updateContact(contact);
-        sendExpirationTimerUpdate(address);
-        account.save();
+    private void setExpirationTimer(RecipientId recipientId, int messageExpirationTimer) {
+        var contact = account.getContactStore().getContact(recipientId);
+        if (contact != null && contact.getMessageExpirationTime() == messageExpirationTimer) {
+            return;
+        }
+        final var builder = contact == null ? Contact.newBuilder() : Contact.newBuilder(contact);
+        account.getContactStore()
+                .storeContact(recipientId, builder.withMessageExpirationTime(messageExpirationTimer).build());
     }
 
-    private void sendExpirationTimerUpdate(SignalServiceAddress address) throws IOException {
+    private void sendExpirationTimerUpdate(RecipientId recipientId) throws IOException {
         final var messageBuilder = SignalServiceDataMessage.newBuilder().asExpirationUpdate();
-        sendMessage(messageBuilder, List.of(address));
+        sendMessage(messageBuilder, Set.of(recipientId));
     }
 
     /**
@@ -1099,8 +1235,9 @@ public class Manager implements Closeable {
     public void setExpirationTimer(
             String number, int messageExpirationTimer
     ) throws IOException, InvalidNumberException {
-        var address = canonicalizeAndResolveSignalServiceAddress(number);
-        setExpirationTimer(address, messageExpirationTimer);
+        var recipientId = canonicalizeAndResolveRecipient(number);
+        setExpirationTimer(recipientId, messageExpirationTimer);
+        sendExpirationTimerUpdate(recipientId);
     }
 
     /**
@@ -1131,9 +1268,8 @@ public class Manager implements Closeable {
         var packKey = KeyUtils.createStickerUploadKey();
         var packId = messageSender.uploadStickerManifest(manifest, packKey);
 
-        var sticker = new Sticker(Hex.fromStringCondensed(packId), packKey);
+        var sticker = new Sticker(StickerPackId.deserialize(Hex.fromStringCondensed(packId)), packKey);
         account.getStickerStore().updateSticker(sticker);
-        account.save();
 
         try {
             return new URI("https",
@@ -1147,7 +1283,15 @@ public class Manager implements Closeable {
         }
     }
 
-    void requestSyncGroups() throws IOException {
+    public void requestAllSyncData() throws IOException {
+        requestSyncGroups();
+        requestSyncContacts();
+        requestSyncBlocked();
+        requestSyncConfiguration();
+        requestSyncKeys();
+    }
+
+    private void requestSyncGroups() throws IOException {
         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.GROUPS)
                 .build();
@@ -1159,7 +1303,7 @@ public class Manager implements Closeable {
         }
     }
 
-    void requestSyncContacts() throws IOException {
+    private void requestSyncContacts() throws IOException {
         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.CONTACTS)
                 .build();
@@ -1171,7 +1315,7 @@ public class Manager implements Closeable {
         }
     }
 
-    void requestSyncBlocked() throws IOException {
+    private void requestSyncBlocked() throws IOException {
         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.BLOCKED)
                 .build();
@@ -1183,7 +1327,7 @@ public class Manager implements Closeable {
         }
     }
 
-    void requestSyncConfiguration() throws IOException {
+    private void requestSyncConfiguration() throws IOException {
         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.CONFIGURATION)
                 .build();
@@ -1195,7 +1339,7 @@ public class Manager implements Closeable {
         }
     }
 
-    void requestSyncKeys() throws IOException {
+    private void requestSyncKeys() throws IOException {
         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.KEYS)
                 .build();
@@ -1208,11 +1352,13 @@ public class Manager implements Closeable {
     }
 
     private byte[] getSenderCertificate() {
-        // TODO support UUID capable sender certificates
-        // byte[] certificate = accountManager.getSenderCertificateForPhoneNumberPrivacy();
         byte[] certificate;
         try {
-            certificate = accountManager.getSenderCertificate();
+            if (account.isPhoneNumberShared()) {
+                certificate = accountManager.getSenderCertificate();
+            } else {
+                certificate = accountManager.getSenderCertificateForPhoneNumberPrivacy();
+            }
         } catch (IOException e) {
             logger.warn("Failed to get sender certificate, ignoring: {}", e.getMessage());
             return null;
@@ -1223,25 +1369,15 @@ public class Manager implements Closeable {
 
     private void sendSyncMessage(SignalServiceSyncMessage message) throws IOException, UntrustedIdentityException {
         var messageSender = createMessageSender();
-        try {
-            messageSender.sendMessage(message, unidentifiedAccessHelper.getAccessForSync());
-        } catch (UntrustedIdentityException e) {
-            if (e.getIdentityKey() != null) {
-                account.getSignalProtocolStore()
-                        .saveIdentity(resolveSignalServiceAddress(e.getIdentifier()),
-                                e.getIdentityKey(),
-                                TrustLevel.UNTRUSTED);
-            }
-            throw e;
-        }
+        messageSender.sendMessage(message, unidentifiedAccessHelper.getAccessForSync());
     }
 
-    private Collection<SignalServiceAddress> getSignalServiceAddresses(Collection<String> numbers) throws InvalidNumberException {
+    private Set<RecipientId> getSignalServiceAddresses(Collection<String> numbers) throws InvalidNumberException {
         final var signalServiceAddresses = new HashSet<SignalServiceAddress>(numbers.size());
         final var addressesMissingUuid = new HashSet<SignalServiceAddress>();
 
         for (var number : numbers) {
-            final var resolvedAddress = canonicalizeAndResolveSignalServiceAddress(number);
+            final var resolvedAddress = resolveSignalServiceAddress(canonicalizeAndResolveRecipient(number));
             if (resolvedAddress.getUuid().isPresent()) {
                 signalServiceAddresses.add(resolvedAddress);
             } else {
@@ -1263,21 +1399,32 @@ public class Manager implements Closeable {
         for (var address : addressesMissingUuid) {
             final var number = address.getNumber().get();
             if (registeredUsers.containsKey(number)) {
-                final var newAddress = resolveSignalServiceAddress(new SignalServiceAddress(registeredUsers.get(number),
-                        number));
+                final var newAddress = resolveSignalServiceAddress(resolveRecipientTrusted(new SignalServiceAddress(
+                        registeredUsers.get(number),
+                        number)));
                 signalServiceAddresses.add(newAddress);
             } else {
                 signalServiceAddresses.add(address);
             }
         }
 
-        return signalServiceAddresses;
+        return signalServiceAddresses.stream().map(this::resolveRecipient).collect(Collectors.toSet());
     }
 
-    private Map<String, UUID> getRegisteredUsers(final Set<String> numbersMissingUuid) throws IOException {
+    private RecipientId refreshRegisteredUser(RecipientId recipientId) throws IOException {
+        final var address = resolveSignalServiceAddress(recipientId);
+        if (!address.getNumber().isPresent()) {
+            return recipientId;
+        }
+        final var number = address.getNumber().get();
+        final var uuidMap = getRegisteredUsers(Set.of(number));
+        return resolveRecipientTrusted(new SignalServiceAddress(uuidMap.getOrDefault(number, null), number));
+    }
+
+    private Map<String, UUID> getRegisteredUsers(final Set<String> numbers) throws IOException {
         try {
             return accountManager.getRegisteredUsers(ServiceConfig.getIasKeyStore(),
-                    numbersMissingUuid,
+                    numbers,
                     serviceEnvironmentConfig.getCdsMrenclave());
         } catch (Quote.InvalidQuoteFormatException | UnauthenticatedQuoteException | SignatureException | UnauthenticatedResponseException | InvalidKeyException e) {
             throw new IOException(e);
@@ -1285,9 +1432,8 @@ public class Manager implements Closeable {
     }
 
     private Pair<Long, List<SendMessageResult>> sendMessage(
-            SignalServiceDataMessage.Builder messageBuilder, Collection<SignalServiceAddress> recipients
+            SignalServiceDataMessage.Builder messageBuilder, Set<RecipientId> recipientIds
     ) throws IOException {
-        recipients = recipients.stream().map(this::resolveSignalServiceAddress).collect(Collectors.toSet());
         final var timestamp = System.currentTimeMillis();
         messageBuilder.withTimestamp(timestamp);
         getOrCreateMessagePipe();
@@ -1299,48 +1445,49 @@ public class Manager implements Closeable {
                 try {
                     var messageSender = createMessageSender();
                     final var isRecipientUpdate = false;
-                    var result = messageSender.sendMessage(new ArrayList<>(recipients),
-                            unidentifiedAccessHelper.getAccessFor(recipients),
+                    final var recipientIdList = new ArrayList<>(recipientIds);
+                    final var addresses = recipientIdList.stream()
+                            .map(this::resolveSignalServiceAddress)
+                            .collect(Collectors.toList());
+                    var result = messageSender.sendMessage(addresses,
+                            unidentifiedAccessHelper.getAccessFor(recipientIdList),
                             isRecipientUpdate,
                             message);
+
                     for (var r : result) {
                         if (r.getIdentityFailure() != null) {
-                            account.getSignalProtocolStore()
-                                    .saveIdentity(r.getAddress(),
-                                            r.getIdentityFailure().getIdentityKey(),
-                                            TrustLevel.UNTRUSTED);
+                            final var recipientId = resolveRecipient(r.getAddress());
+                            final var newIdentity = account.getIdentityKeyStore()
+                                    .saveIdentity(recipientId, r.getIdentityFailure().getIdentityKey(), new Date());
+                            if (newIdentity) {
+                                account.getSessionStore().archiveSessions(recipientId);
+                            }
                         }
                     }
+
                     return new Pair<>(timestamp, result);
                 } catch (UntrustedIdentityException e) {
-                    if (e.getIdentityKey() != null) {
-                        account.getSignalProtocolStore()
-                                .saveIdentity(resolveSignalServiceAddress(e.getIdentifier()),
-                                        e.getIdentityKey(),
-                                        TrustLevel.UNTRUSTED);
-                    }
                     return new Pair<>(timestamp, List.of());
                 }
             } else {
                 // Send to all individually, so sync messages are sent correctly
                 messageBuilder.withProfileKey(account.getProfileKey().serialize());
-                var results = new ArrayList<SendMessageResult>(recipients.size());
-                for (var address : recipients) {
-                    final var contact = account.getContactStore().getContact(address);
-                    final var expirationTime = contact != null ? contact.messageExpirationTime : 0;
+                var results = new ArrayList<SendMessageResult>(recipientIds.size());
+                for (var recipientId : recipientIds) {
+                    final var contact = account.getContactStore().getContact(recipientId);
+                    final var expirationTime = contact != null ? contact.getMessageExpirationTime() : 0;
                     messageBuilder.withExpiration(expirationTime);
                     message = messageBuilder.build();
-                    results.add(sendMessage(address, message));
+                    results.add(sendMessage(recipientId, message));
                 }
                 return new Pair<>(timestamp, results);
             }
         } finally {
             if (message != null && message.isEndSession()) {
-                for (var recipient : recipients) {
+                for (var recipient : recipientIds) {
                     handleEndSession(recipient);
                 }
             }
-            account.save();
         }
     }
 
@@ -1351,27 +1498,24 @@ public class Manager implements Closeable {
         messageBuilder.withTimestamp(timestamp);
         getOrCreateMessagePipe();
         getOrCreateUnidentifiedMessagePipe();
-        try {
-            final var address = getSelfAddress();
+        final var recipientId = account.getSelfRecipientId();
 
-            final var contact = account.getContactStore().getContact(address);
-            final var expirationTime = contact != null ? contact.messageExpirationTime : 0;
-            messageBuilder.withExpiration(expirationTime);
+        final var contact = account.getContactStore().getContact(recipientId);
+        final var expirationTime = contact != null ? contact.getMessageExpirationTime() : 0;
+        messageBuilder.withExpiration(expirationTime);
 
-            var message = messageBuilder.build();
-            final var result = sendSelfMessage(message);
-            return new Pair<>(timestamp, result);
-        } finally {
-            account.save();
-        }
+        var message = messageBuilder.build();
+        final var result = sendSelfMessage(message);
+        return new Pair<>(timestamp, result);
     }
 
     private SendMessageResult sendSelfMessage(SignalServiceDataMessage message) throws IOException {
         var messageSender = createMessageSender();
 
-        var recipient = account.getSelfAddress();
+        var recipientId = account.getSelfRecipientId();
 
-        final var unidentifiedAccess = unidentifiedAccessHelper.getAccessFor(recipient);
+        final var unidentifiedAccess = unidentifiedAccessHelper.getAccessFor(recipientId);
+        var recipient = resolveSignalServiceAddress(recipientId);
         var transcript = new SentTranscriptMessage(Optional.of(recipient),
                 message.getTimestamp(),
                 message,
@@ -1388,58 +1532,57 @@ public class Manager implements Closeable {
                     false,
                     System.currentTimeMillis() - startTime);
         } catch (UntrustedIdentityException e) {
-            if (e.getIdentityKey() != null) {
-                account.getSignalProtocolStore()
-                        .saveIdentity(resolveSignalServiceAddress(e.getIdentifier()),
-                                e.getIdentityKey(),
-                                TrustLevel.UNTRUSTED);
-            }
             return SendMessageResult.identityFailure(recipient, e.getIdentityKey());
         }
     }
 
     private SendMessageResult sendMessage(
-            SignalServiceAddress address, SignalServiceDataMessage message
+            RecipientId recipientId, SignalServiceDataMessage message
     ) throws IOException {
         var messageSender = createMessageSender();
 
+        final var address = resolveSignalServiceAddress(recipientId);
         try {
-            return messageSender.sendMessage(address, unidentifiedAccessHelper.getAccessFor(address), message);
+            try {
+                return messageSender.sendMessage(address, unidentifiedAccessHelper.getAccessFor(recipientId), message);
+            } catch (UnregisteredUserException e) {
+                final var newRecipientId = refreshRegisteredUser(recipientId);
+                return messageSender.sendMessage(resolveSignalServiceAddress(newRecipientId),
+                        unidentifiedAccessHelper.getAccessFor(newRecipientId),
+                        message);
+            }
         } catch (UntrustedIdentityException e) {
-            if (e.getIdentityKey() != null) {
-                account.getSignalProtocolStore()
-                        .saveIdentity(resolveSignalServiceAddress(e.getIdentifier()),
-                                e.getIdentityKey(),
-                                TrustLevel.UNTRUSTED);
+            return SendMessageResult.identityFailure(address, e.getIdentityKey());
+        }
+    }
+
+    private SendMessageResult sendNullMessage(RecipientId recipientId) throws IOException {
+        var messageSender = createMessageSender();
+
+        final var address = resolveSignalServiceAddress(recipientId);
+        try {
+            try {
+                return messageSender.sendNullMessage(address, unidentifiedAccessHelper.getAccessFor(recipientId));
+            } catch (UnregisteredUserException e) {
+                final var newRecipientId = refreshRegisteredUser(recipientId);
+                final var newAddress = resolveSignalServiceAddress(newRecipientId);
+                return messageSender.sendNullMessage(newAddress, unidentifiedAccessHelper.getAccessFor(newRecipientId));
             }
+        } catch (UntrustedIdentityException e) {
             return SendMessageResult.identityFailure(address, e.getIdentityKey());
         }
     }
 
-    private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws InvalidMetadataMessageException, ProtocolInvalidMessageException, ProtocolDuplicateMessageException, ProtocolLegacyMessageException, ProtocolInvalidKeyIdException, InvalidMetadataVersionException, ProtocolInvalidVersionException, ProtocolNoSessionException, ProtocolInvalidKeyException, SelfSendException, UnsupportedDataMessageException, org.whispersystems.libsignal.UntrustedIdentityException {
+    private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws InvalidMetadataMessageException, ProtocolInvalidMessageException, ProtocolDuplicateMessageException, ProtocolLegacyMessageException, ProtocolInvalidKeyIdException, InvalidMetadataVersionException, ProtocolInvalidVersionException, ProtocolNoSessionException, ProtocolInvalidKeyException, SelfSendException, UnsupportedDataMessageException, ProtocolUntrustedIdentityException {
         var cipher = new SignalServiceCipher(account.getSelfAddress(),
                 account.getSignalProtocolStore(),
+                sessionLock,
                 certificateValidator);
-        try {
-            return cipher.decrypt(envelope);
-        } catch (ProtocolUntrustedIdentityException e) {
-            if (e.getCause() instanceof org.whispersystems.libsignal.UntrustedIdentityException) {
-                var identityException = (org.whispersystems.libsignal.UntrustedIdentityException) e.getCause();
-                final var untrustedIdentity = identityException.getUntrustedIdentity();
-                if (untrustedIdentity != null) {
-                    account.getSignalProtocolStore()
-                            .saveIdentity(resolveSignalServiceAddress(identityException.getName()),
-                                    untrustedIdentity,
-                                    TrustLevel.UNTRUSTED);
-                }
-                throw identityException;
-            }
-            throw new AssertionError(e);
-        }
+        return cipher.decrypt(envelope);
     }
 
-    private void handleEndSession(SignalServiceAddress source) {
-        account.getSessionStore().deleteAllSessions(source.getIdentifier());
+    private void handleEndSession(RecipientId recipientId) {
+        account.getSessionStore().deleteAllSessions(recipientId);
     }
 
     private List<HandleAction> handleSignalServiceDataMessage(
@@ -1476,7 +1619,7 @@ public class Manager implements Closeable {
                                 groupV1.addMembers(groupInfo.getMembers()
                                         .get()
                                         .stream()
-                                        .map(this::resolveSignalServiceAddress)
+                                        .map(this::resolveRecipient)
                                         .collect(Collectors.toSet()));
                             }
 
@@ -1490,7 +1633,7 @@ public class Manager implements Closeable {
                             break;
                         case QUIT: {
                             if (groupV1 != null) {
-                                groupV1.removeMember(source);
+                                groupV1.removeMember(resolveRecipient(source));
                                 account.getGroupStore().updateGroup(groupV1);
                             }
                             break;
@@ -1517,7 +1660,7 @@ public class Manager implements Closeable {
 
         final var conversationPartnerAddress = isSync ? destination : source;
         if (conversationPartnerAddress != null && message.isEndSession()) {
-            handleEndSession(conversationPartnerAddress);
+            handleEndSession(resolveRecipient(conversationPartnerAddress));
         }
         if (message.isExpirationUpdate() || message.getBody().isPresent()) {
             if (message.getGroupContext().isPresent()) {
@@ -1534,14 +1677,7 @@ public class Manager implements Closeable {
                     // disappearing message timer already stored in the DecryptedGroup
                 }
             } else if (conversationPartnerAddress != null) {
-                var contact = account.getContactStore().getContact(conversationPartnerAddress);
-                if (contact == null) {
-                    contact = new ContactInfo(conversationPartnerAddress);
-                }
-                if (contact.messageExpirationTime != message.getExpiresInSeconds()) {
-                    contact.messageExpirationTime = message.getExpiresInSeconds();
-                    account.getContactStore().updateContact(contact);
-                }
+                setExpirationTimer(resolveRecipient(conversationPartnerAddress), message.getExpiresInSeconds());
             }
         }
         if (!ignoreAttachments) {
@@ -1568,7 +1704,7 @@ public class Manager implements Closeable {
             if (source.matches(account.getSelfAddress())) {
                 this.account.setProfileKey(profileKey);
             }
-            this.account.getProfileStore().storeProfileKey(source, profileKey);
+            this.account.getProfileStore().storeProfileKey(resolveRecipient(source), profileKey);
         }
         if (message.getPreviews().isPresent()) {
             final var previews = message.getPreviews().get();
@@ -1590,9 +1726,10 @@ public class Manager implements Closeable {
         }
         if (message.getSticker().isPresent()) {
             final var messageSticker = message.getSticker().get();
-            var sticker = account.getStickerStore().getSticker(messageSticker.getPackId());
+            final var stickerPackId = StickerPackId.deserialize(messageSticker.getPackId());
+            var sticker = account.getStickerStore().getSticker(stickerPackId);
             if (sticker == null) {
-                sticker = new Sticker(messageSticker.getPackId(), messageSticker.getPackKey());
+                sticker = new Sticker(stickerPackId, messageSticker.getPackKey());
                 account.getStickerStore().updateSticker(sticker);
             }
         }
@@ -1609,7 +1746,7 @@ public class Manager implements Closeable {
         final GroupInfoV2 groupInfoV2;
         if (groupInfo instanceof GroupInfoV1) {
             // Received a v2 group message for a v1 group, we need to locally migrate the group
-            account.getGroupStore().deleteGroup(groupInfo.getGroupId());
+            account.getGroupStore().deleteGroupV1(((GroupInfoV1) groupInfo).getGroupId());
             groupInfoV2 = new GroupInfoV2(groupId, groupMasterKey);
             logger.info("Locally migrated group {} to group v2, id: {}",
                     groupInfo.getGroupId().toBase64(),
@@ -1625,10 +1762,12 @@ public class Manager implements Closeable {
             if (signedGroupChange != null
                     && groupInfoV2.getGroup() != null
                     && groupInfoV2.getGroup().getRevision() + 1 == revision) {
-                group = groupHelper.getUpdatedDecryptedGroup(groupInfoV2.getGroup(), signedGroupChange, groupMasterKey);
+                group = groupV2Helper.getUpdatedDecryptedGroup(groupInfoV2.getGroup(),
+                        signedGroupChange,
+                        groupMasterKey);
             }
             if (group == null) {
-                group = groupHelper.getDecryptedGroup(groupSecretParams);
+                group = groupV2Helper.getDecryptedGroup(groupSecretParams);
             }
             if (group != null) {
                 storeProfileKeysFromMembers(group);
@@ -1637,7 +1776,7 @@ public class Manager implements Closeable {
                     downloadGroupAvatar(groupId, groupSecretParams, avatar);
                 }
             }
-            groupInfoV2.setGroup(group);
+            groupInfoV2.setGroup(group, this::resolveRecipient);
             account.getGroupStore().updateGroup(groupInfoV2);
         }
 
@@ -1646,52 +1785,66 @@ public class Manager implements Closeable {
 
     private void storeProfileKeysFromMembers(final DecryptedGroup group) {
         for (var member : group.getMembersList()) {
-            final var address = resolveSignalServiceAddress(new SignalServiceAddress(UuidUtil.parseOrThrow(member.getUuid()
-                    .toByteArray()), null));
+            final var uuid = UuidUtil.parseOrThrow(member.getUuid().toByteArray());
+            final var recipientId = account.getRecipientStore().resolveRecipient(uuid);
             try {
                 account.getProfileStore()
-                        .storeProfileKey(address, new ProfileKey(member.getProfileKey().toByteArray()));
+                        .storeProfileKey(recipientId, new ProfileKey(member.getProfileKey().toByteArray()));
             } catch (InvalidInputException ignored) {
             }
         }
     }
 
     private void retryFailedReceivedMessages(ReceiveMessageHandler handler, boolean ignoreAttachments) {
+        Set<HandleAction> queuedActions = new HashSet<>();
         for (var cachedMessage : account.getMessageCache().getCachedMessages()) {
-            retryFailedReceivedMessage(handler, ignoreAttachments, cachedMessage);
+            var actions = retryFailedReceivedMessage(handler, ignoreAttachments, cachedMessage);
+            if (actions != null) {
+                queuedActions.addAll(actions);
+            }
+        }
+        for (var action : queuedActions) {
+            try {
+                action.execute(this);
+            } catch (Throwable e) {
+                logger.warn("Message action failed.", e);
+            }
         }
     }
 
-    private void retryFailedReceivedMessage(
+    private List<HandleAction> retryFailedReceivedMessage(
             final ReceiveMessageHandler handler, final boolean ignoreAttachments, final CachedMessage cachedMessage
     ) {
         var envelope = cachedMessage.loadEnvelope();
         if (envelope == null) {
-            return;
+            return null;
         }
         SignalServiceContent content = null;
+        List<HandleAction> actions = null;
         if (!envelope.isReceipt()) {
             try {
                 content = decryptMessage(envelope);
-            } catch (org.whispersystems.libsignal.UntrustedIdentityException e) {
-                return;
+            } catch (ProtocolUntrustedIdentityException e) {
+                if (!envelope.hasSource()) {
+                    final var identifier = e.getSender();
+                    final var recipientId = resolveRecipient(identifier);
+                    try {
+                        account.getMessageCache().replaceSender(cachedMessage, recipientId);
+                    } catch (IOException ioException) {
+                        logger.warn("Failed to move cached message to recipient folder: {}", ioException.getMessage());
+                    }
+                }
+                return null;
             } catch (Exception er) {
                 // All other errors are not recoverable, so delete the cached message
                 cachedMessage.delete();
-                return;
-            }
-            var actions = handleMessage(envelope, content, ignoreAttachments);
-            for (var action : actions) {
-                try {
-                    action.execute(this);
-                } catch (Throwable e) {
-                    logger.warn("Message action failed.", e);
-                }
+                return null;
             }
+            actions = handleMessage(envelope, content, ignoreAttachments);
         }
-        account.save();
         handler.handleMessage(envelope, content, null);
         cachedMessage.delete();
+        return actions;
     }
 
     public void receiveMessages(
@@ -1716,8 +1869,11 @@ public class Manager implements Closeable {
             final CachedMessage[] cachedMessage = {null};
             try {
                 var result = messagePipe.readOrEmpty(timeout, unit, envelope1 -> {
+                    final var recipientId = envelope1.hasSource()
+                            ? resolveRecipient(envelope1.getSourceIdentifier())
+                            : null;
                     // store message on disk, before acknowledging receipt to the server
-                    cachedMessage[0] = account.getMessageCache().cacheMessage(envelope1);
+                    cachedMessage[0] = account.getMessageCache().cacheMessage(envelope1, recipientId);
                 });
                 if (result.isPresent()) {
                     envelope = result.get();
@@ -1733,7 +1889,6 @@ public class Manager implements Closeable {
                                 logger.warn("Message action failed.", e);
                             }
                         }
-                        account.save();
                         queuedActions.clear();
                         queuedActions = null;
                     }
@@ -1748,16 +1903,27 @@ public class Manager implements Closeable {
 
             if (envelope.hasSource()) {
                 // Store uuid if we don't have it already
-                var source = envelope.getSourceAddress();
-                resolveSignalServiceAddress(source);
+                // address/uuid in envelope is sent by server
+                resolveRecipientTrusted(envelope.getSourceAddress());
             }
+            final var notAGroupMember = isNotAGroupMember(envelope, content);
             if (!envelope.isReceipt()) {
                 try {
                     content = decryptMessage(envelope);
                 } catch (Exception e) {
                     exception = e;
                 }
+                if (!envelope.hasSource() && content != null) {
+                    // Store uuid if we don't have it already
+                    // address/uuid is validated by unidentified sender certificate
+                    resolveRecipientTrusted(content.getSender());
+                }
                 var actions = handleMessage(envelope, content, ignoreAttachments);
+                if (exception instanceof ProtocolInvalidMessageException) {
+                    final var sender = resolveRecipient(((ProtocolInvalidMessageException) exception).getSender());
+                    logger.debug("Received invalid message, queuing renew session action.");
+                    actions.add(new RenewSessionAction(sender));
+                }
                 if (hasCaughtUpWithOldMessages) {
                     for (var action : actions) {
                         try {
@@ -1773,16 +1939,27 @@ public class Manager implements Closeable {
                     queuedActions.addAll(actions);
                 }
             }
-            account.save();
             if (isMessageBlocked(envelope, content)) {
                 logger.info("Ignoring a message from blocked user/group: {}", envelope.getTimestamp());
-            } else if (isNotAGroupMember(envelope, content)) {
+            } else if (notAGroupMember) {
                 logger.info("Ignoring a message from a non group member: {}", envelope.getTimestamp());
             } else {
                 handler.handleMessage(envelope, content, exception);
             }
-            if (!(exception instanceof org.whispersystems.libsignal.UntrustedIdentityException)) {
-                if (cachedMessage[0] != null) {
+            if (cachedMessage[0] != null) {
+                if (exception instanceof ProtocolUntrustedIdentityException) {
+                    final var identifier = ((ProtocolUntrustedIdentityException) exception).getSender();
+                    final var recipientId = resolveRecipient(identifier);
+                    queuedActions.add(new RetrieveProfileAction(recipientId));
+                    if (!envelope.hasSource()) {
+                        try {
+                            cachedMessage[0] = account.getMessageCache().replaceSender(cachedMessage[0], recipientId);
+                        } catch (IOException ioException) {
+                            logger.warn("Failed to move cached message to recipient folder: {}",
+                                    ioException.getMessage());
+                        }
+                    }
+                } else {
                     cachedMessage[0].delete();
                 }
             }
@@ -1800,8 +1977,8 @@ public class Manager implements Closeable {
         } else {
             return false;
         }
-        var sourceContact = account.getContactStore().getContact(source);
-        if (sourceContact != null && sourceContact.blocked) {
+        final var recipientId = resolveRecipient(source);
+        if (isContactBlocked(recipientId)) {
             return true;
         }
 
@@ -1818,6 +1995,16 @@ public class Manager implements Closeable {
         return false;
     }
 
+    public boolean isContactBlocked(final String identifier) throws InvalidNumberException {
+        final var recipientId = canonicalizeAndResolveRecipient(identifier);
+        return isContactBlocked(recipientId);
+    }
+
+    private boolean isContactBlocked(final RecipientId recipientId) {
+        var sourceContact = account.getContactStore().getContact(recipientId);
+        return sourceContact != null && sourceContact.isBlocked();
+    }
+
     private boolean isNotAGroupMember(
             SignalServiceEnvelope envelope, SignalServiceContent content
     ) {
@@ -1841,7 +2028,7 @@ public class Manager implements Closeable {
                 }
                 var groupId = GroupUtils.getGroupId(message.getGroupContext().get());
                 var group = getGroup(groupId);
-                if (group != null && !group.isMember(source)) {
+                if (group != null && !group.isMember(resolveRecipient(source))) {
                     return true;
                 }
             }
@@ -1860,8 +2047,6 @@ public class Manager implements Closeable {
             } else {
                 sender = content.getSender();
             }
-            // Store uuid if we don't have it already
-            resolveSignalServiceAddress(sender);
 
             if (content.getDataMessage().isPresent()) {
                 var message = content.getDataMessage().get();
@@ -1888,7 +2073,7 @@ public class Manager implements Closeable {
                             destination,
                             ignoreAttachments));
                 }
-                if (syncMessage.getRequest().isPresent()) {
+                if (syncMessage.getRequest().isPresent() && account.isMasterDevice()) {
                     var rm = syncMessage.getRequest().get();
                     if (rm.isContactsRequest()) {
                         actions.add(SendSyncContactsAction.create());
@@ -1917,13 +2102,13 @@ public class Manager implements Closeable {
                                     }
                                     syncGroup.addMembers(g.getMembers()
                                             .stream()
-                                            .map(this::resolveSignalServiceAddress)
+                                            .map(this::resolveRecipient)
                                             .collect(Collectors.toSet()));
                                     if (!g.isActive()) {
-                                        syncGroup.removeMember(account.getSelfAddress());
+                                        syncGroup.removeMember(account.getSelfRecipientId());
                                     } else {
                                         // Add ourself to the member set as it's marked as active
-                                        syncGroup.addMembers(List.of(account.getSelfAddress()));
+                                        syncGroup.addMembers(List.of(account.getSelfRecipientId()));
                                     }
                                     syncGroup.blocked = g.isBlocked();
                                     if (g.getColor().isPresent()) {
@@ -1933,7 +2118,6 @@ public class Manager implements Closeable {
                                     if (g.getAvatar().isPresent()) {
                                         downloadGroupAvatar(g.getAvatar().get(), syncGroup.getGroupId());
                                     }
-                                    syncGroup.inboxPosition = g.getInboxPosition().orNull();
                                     syncGroup.archived = g.isArchived();
                                     account.getGroupStore().updateGroup(syncGroup);
                                 }
@@ -1958,7 +2142,7 @@ public class Manager implements Closeable {
                 if (syncMessage.getBlockedList().isPresent()) {
                     final var blockedListMessage = syncMessage.getBlockedList().get();
                     for (var address : blockedListMessage.getAddresses()) {
-                        setContactBlocked(resolveSignalServiceAddress(address), true);
+                        setContactBlocked(resolveRecipient(address), true);
                     }
                     for (var groupId : blockedListMessage.getGroupIds()
                             .stream()
@@ -1980,45 +2164,41 @@ public class Manager implements Closeable {
                         try (var attachmentAsStream = retrieveAttachmentAsStream(contactsMessage.getContactsStream()
                                 .asPointer(), tmpFile)) {
                             var s = new DeviceContactsInputStream(attachmentAsStream);
-                            if (contactsMessage.isComplete()) {
-                                account.getContactStore().clear();
-                            }
                             DeviceContact c;
                             while ((c = s.read()) != null) {
                                 if (c.getAddress().matches(account.getSelfAddress()) && c.getProfileKey().isPresent()) {
                                     account.setProfileKey(c.getProfileKey().get());
                                 }
-                                final var address = resolveSignalServiceAddress(c.getAddress());
-                                var contact = account.getContactStore().getContact(address);
-                                if (contact == null) {
-                                    contact = new ContactInfo(address);
-                                }
+                                final var recipientId = resolveRecipientTrusted(c.getAddress());
+                                var contact = account.getContactStore().getContact(recipientId);
+                                final var builder = contact == null
+                                        ? Contact.newBuilder()
+                                        : Contact.newBuilder(contact);
                                 if (c.getName().isPresent()) {
-                                    contact.name = c.getName().get();
+                                    builder.withName(c.getName().get());
                                 }
                                 if (c.getColor().isPresent()) {
-                                    contact.color = c.getColor().get();
+                                    builder.withColor(c.getColor().get());
                                 }
                                 if (c.getProfileKey().isPresent()) {
-                                    account.getProfileStore().storeProfileKey(address, c.getProfileKey().get());
+                                    account.getProfileStore().storeProfileKey(recipientId, c.getProfileKey().get());
                                 }
                                 if (c.getVerified().isPresent()) {
                                     final var verifiedMessage = c.getVerified().get();
-                                    account.getSignalProtocolStore()
-                                            .setIdentityTrustLevel(verifiedMessage.getDestination(),
+                                    account.getIdentityKeyStore()
+                                            .setIdentityTrustLevel(resolveRecipientTrusted(verifiedMessage.getDestination()),
                                                     verifiedMessage.getIdentityKey(),
                                                     TrustLevel.fromVerifiedState(verifiedMessage.getVerified()));
                                 }
                                 if (c.getExpirationTimer().isPresent()) {
-                                    contact.messageExpirationTime = c.getExpirationTimer().get();
+                                    builder.withMessageExpirationTime(c.getExpirationTimer().get());
                                 }
-                                contact.blocked = c.isBlocked();
-                                contact.inboxPosition = c.getInboxPosition().orNull();
-                                contact.archived = c.isArchived();
-                                account.getContactStore().updateContact(contact);
+                                builder.withBlocked(c.isBlocked());
+                                builder.withArchived(c.isArchived());
+                                account.getContactStore().storeContact(recipientId, builder.build());
 
                                 if (c.getAvatar().isPresent()) {
-                                    downloadContactAvatar(c.getAvatar().get(), contact.getAddress());
+                                    downloadContactAvatar(c.getAvatar().get(), c.getAddress());
                                 }
                             }
                         }
@@ -2040,8 +2220,8 @@ public class Manager implements Closeable {
                 }
                 if (syncMessage.getVerified().isPresent()) {
                     final var verifiedMessage = syncMessage.getVerified().get();
-                    account.getSignalProtocolStore()
-                            .setIdentityTrustLevel(resolveSignalServiceAddress(verifiedMessage.getDestination()),
+                    account.getIdentityKeyStore()
+                            .setIdentityTrustLevel(resolveRecipientTrusted(verifiedMessage.getDestination()),
                                     verifiedMessage.getIdentityKey(),
                                     TrustLevel.fromVerifiedState(verifiedMessage.getVerified()));
                 }
@@ -2051,12 +2231,13 @@ public class Manager implements Closeable {
                         if (!m.getPackId().isPresent()) {
                             continue;
                         }
-                        var sticker = account.getStickerStore().getSticker(m.getPackId().get());
+                        final var stickerPackId = StickerPackId.deserialize(m.getPackId().get());
+                        var sticker = account.getStickerStore().getSticker(stickerPackId);
                         if (sticker == null) {
                             if (!m.getPackKey().isPresent()) {
                                 continue;
                             }
-                            sticker = new Sticker(m.getPackId().get(), m.getPackKey().get());
+                            sticker = new Sticker(stickerPackId, m.getPackKey().get());
                         }
                         sticker.setInstalled(!m.getType().isPresent()
                                 || m.getType().get() == StickerPackOperationMessage.Type.INSTALL);
@@ -2066,7 +2247,7 @@ public class Manager implements Closeable {
                 if (syncMessage.getFetchType().isPresent()) {
                     switch (syncMessage.getFetchType().get()) {
                         case LOCAL_PROFILE:
-                            getRecipientProfile(getSelfAddress(), true);
+                            getRecipientProfile(account.getSelfRecipientId(), true);
                         case STORAGE_MANIFEST:
                             // TODO
                     }
@@ -2243,13 +2424,16 @@ public class Manager implements Closeable {
                         var groupInfo = (GroupInfoV1) record;
                         out.write(new DeviceGroup(groupInfo.getGroupId().serialize(),
                                 Optional.fromNullable(groupInfo.name),
-                                new ArrayList<>(groupInfo.getMembers()),
+                                groupInfo.getMembers()
+                                        .stream()
+                                        .map(this::resolveSignalServiceAddress)
+                                        .collect(Collectors.toList()),
                                 createGroupAvatarAttachment(groupInfo.getGroupId()),
-                                groupInfo.isMember(account.getSelfAddress()),
+                                groupInfo.isMember(account.getSelfRecipientId()),
                                 Optional.of(groupInfo.messageExpirationTime),
                                 Optional.fromNullable(groupInfo.color),
                                 groupInfo.blocked,
-                                Optional.fromNullable(groupInfo.inboxPosition),
+                                Optional.absent(),
                                 groupInfo.archived));
                     }
                 }
@@ -2281,27 +2465,31 @@ public class Manager implements Closeable {
         try {
             try (OutputStream fos = new FileOutputStream(contactsFile)) {
                 var out = new DeviceContactsOutputStream(fos);
-                for (var record : account.getContactStore().getContacts()) {
+                for (var contactPair : account.getContactStore().getContacts()) {
+                    final var recipientId = contactPair.first();
+                    final var contact = contactPair.second();
+                    final var address = resolveSignalServiceAddress(recipientId);
+
+                    var currentIdentity = account.getIdentityKeyStore().getIdentity(recipientId);
                     VerifiedMessage verifiedMessage = null;
-                    var currentIdentity = account.getSignalProtocolStore().getIdentity(record.getAddress());
                     if (currentIdentity != null) {
-                        verifiedMessage = new VerifiedMessage(record.getAddress(),
+                        verifiedMessage = new VerifiedMessage(address,
                                 currentIdentity.getIdentityKey(),
                                 currentIdentity.getTrustLevel().toVerifiedState(),
                                 currentIdentity.getDateAdded().getTime());
                     }
 
-                    var profileKey = account.getProfileStore().getProfileKey(record.getAddress());
-                    out.write(new DeviceContact(record.getAddress(),
-                            Optional.fromNullable(record.name),
-                            createContactAvatarAttachment(record.getAddress()),
-                            Optional.fromNullable(record.color),
+                    var profileKey = account.getProfileStore().getProfileKey(recipientId);
+                    out.write(new DeviceContact(address,
+                            Optional.fromNullable(contact.getName()),
+                            createContactAvatarAttachment(address),
+                            Optional.fromNullable(contact.getColor()),
                             Optional.fromNullable(verifiedMessage),
                             Optional.fromNullable(profileKey),
-                            record.blocked,
-                            Optional.of(record.messageExpirationTime),
-                            Optional.fromNullable(record.inboxPosition),
-                            record.archived));
+                            contact.isBlocked(),
+                            Optional.of(contact.getMessageExpirationTime()),
+                            Optional.absent(),
+                            contact.isArchived()));
                 }
 
                 if (account.getProfileKey() != null) {
@@ -2342,8 +2530,8 @@ public class Manager implements Closeable {
     void sendBlockedList() throws IOException, UntrustedIdentityException {
         var addresses = new ArrayList<SignalServiceAddress>();
         for (var record : account.getContactStore().getContacts()) {
-            if (record.blocked) {
-                addresses.add(record.getAddress());
+            if (record.second().isBlocked()) {
+                addresses.add(resolveSignalServiceAddress(record.first()));
             }
         }
         var groupIds = new ArrayList<byte[]>();
@@ -2365,22 +2553,25 @@ public class Manager implements Closeable {
         sendSyncMessage(SignalServiceSyncMessage.forVerified(verifiedMessage));
     }
 
-    public List<ContactInfo> getContacts() {
+    public List<Pair<RecipientId, Contact>> getContacts() {
         return account.getContactStore().getContacts();
     }
 
-    public String getContactOrProfileName(String number) {
-        final var address = Utils.getSignalServiceAddressFromIdentifier(number);
+    public String getContactOrProfileName(String number) throws InvalidNumberException {
+        final var recipientId = canonicalizeAndResolveRecipient(number);
+        final var recipient = account.getRecipientStore().getRecipient(recipientId);
+        if (recipient == null) {
+            return null;
+        }
 
-        final var contact = account.getContactStore().getContact(address);
-        if (contact != null && !Util.isEmpty(contact.name)) {
-            return contact.name;
+        if (recipient.getContact() != null && !Util.isEmpty(recipient.getContact().getName())) {
+            return recipient.getContact().getName();
         }
 
-        final var profileEntry = account.getProfileStore().getProfileEntry(address);
-        if (profileEntry != null && profileEntry.getProfile() != null) {
-            return profileEntry.getProfile().getDisplayName();
+        if (recipient.getProfile() != null && recipient.getProfile() != null) {
+            return recipient.getProfile().getDisplayName();
         }
+
         return null;
     }
 
@@ -2388,18 +2579,19 @@ public class Manager implements Closeable {
         final var group = account.getGroupStore().getGroup(groupId);
         if (group instanceof GroupInfoV2 && ((GroupInfoV2) group).getGroup() == null) {
             final var groupSecretParams = GroupSecretParams.deriveFromMasterKey(((GroupInfoV2) group).getMasterKey());
-            ((GroupInfoV2) group).setGroup(groupHelper.getDecryptedGroup(groupSecretParams));
+            ((GroupInfoV2) group).setGroup(groupV2Helper.getDecryptedGroup(groupSecretParams), this::resolveRecipient);
             account.getGroupStore().updateGroup(group);
         }
         return group;
     }
 
     public List<IdentityInfo> getIdentities() {
-        return account.getSignalProtocolStore().getIdentities();
+        return account.getIdentityKeyStore().getIdentities();
     }
 
     public List<IdentityInfo> getIdentities(String number) throws InvalidNumberException {
-        return account.getSignalProtocolStore().getIdentities(canonicalizeAndResolveSignalServiceAddress(number));
+        final var identity = account.getIdentityKeyStore().getIdentity(canonicalizeAndResolveRecipient(number));
+        return identity == null ? List.of() : List.of(identity);
     }
 
     /**
@@ -2409,8 +2601,10 @@ public class Manager implements Closeable {
      * @param fingerprint Fingerprint
      */
     public boolean trustIdentityVerified(String name, byte[] fingerprint) throws InvalidNumberException {
-        var address = canonicalizeAndResolveSignalServiceAddress(name);
-        return trustIdentity(address, (identityKey) -> Arrays.equals(identityKey.serialize(), fingerprint));
+        var recipientId = canonicalizeAndResolveRecipient(name);
+        return trustIdentity(recipientId,
+                identityKey -> Arrays.equals(identityKey.serialize(), fingerprint),
+                TrustLevel.TRUSTED_VERIFIED);
     }
 
     /**
@@ -2420,72 +2614,43 @@ public class Manager implements Closeable {
      * @param safetyNumber Safety number
      */
     public boolean trustIdentityVerifiedSafetyNumber(String name, String safetyNumber) throws InvalidNumberException {
-        var address = canonicalizeAndResolveSignalServiceAddress(name);
-        return trustIdentity(address, (identityKey) -> safetyNumber.equals(computeSafetyNumber(address, identityKey)));
+        var recipientId = canonicalizeAndResolveRecipient(name);
+        var address = account.getRecipientStore().resolveServiceAddress(recipientId);
+        return trustIdentity(recipientId,
+                identityKey -> safetyNumber.equals(computeSafetyNumber(address, identityKey)),
+                TrustLevel.TRUSTED_VERIFIED);
     }
 
-    private boolean trustIdentity(SignalServiceAddress address, Function<IdentityKey, Boolean> verifier) {
-        var ids = account.getSignalProtocolStore().getIdentities(address);
-        if (ids == null) {
-            return false;
-        }
-
-        IdentityInfo foundIdentity = null;
+    /**
+     * Trust all keys of this identity without verification
+     *
+     * @param name username of the identity
+     */
+    public boolean trustIdentityAllKeys(String name) throws InvalidNumberException {
+        var recipientId = canonicalizeAndResolveRecipient(name);
+        return trustIdentity(recipientId, identityKey -> true, TrustLevel.TRUSTED_UNVERIFIED);
+    }
 
-        for (var id : ids) {
-            if (verifier.apply(id.getIdentityKey())) {
-                foundIdentity = id;
-                break;
-            }
+    private boolean trustIdentity(
+            RecipientId recipientId, Function<IdentityKey, Boolean> verifier, TrustLevel trustLevel
+    ) {
+        var identity = account.getIdentityKeyStore().getIdentity(recipientId);
+        if (identity == null) {
+            return false;
         }
 
-        if (foundIdentity == null) {
+        if (!verifier.apply(identity.getIdentityKey())) {
             return false;
         }
 
-        account.getSignalProtocolStore()
-                .setIdentityTrustLevel(address, foundIdentity.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED);
+        account.getIdentityKeyStore().setIdentityTrustLevel(recipientId, identity.getIdentityKey(), trustLevel);
         try {
-            sendVerifiedMessage(address, foundIdentity.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED);
+            var address = account.getRecipientStore().resolveServiceAddress(recipientId);
+            sendVerifiedMessage(address, identity.getIdentityKey(), trustLevel);
         } catch (IOException | UntrustedIdentityException e) {
             logger.warn("Failed to send verification sync message: {}", e.getMessage());
         }
 
-        // Successfully trusted the new identity, now remove all other identities for that number
-        for (var id : ids) {
-            if (id == foundIdentity) {
-                continue;
-            }
-            account.getSignalProtocolStore().removeIdentity(address, id.getIdentityKey());
-        }
-
-        account.save();
-        return true;
-    }
-
-    /**
-     * Trust all keys of this identity without verification
-     *
-     * @param name username of the identity
-     */
-    public boolean trustIdentityAllKeys(String name) {
-        var address = resolveSignalServiceAddress(name);
-        var ids = account.getSignalProtocolStore().getIdentities(address);
-        if (ids == null) {
-            return false;
-        }
-        for (var id : ids) {
-            if (id.getTrustLevel() == TrustLevel.UNTRUSTED) {
-                account.getSignalProtocolStore()
-                        .setIdentityTrustLevel(address, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED);
-                try {
-                    sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED);
-                } catch (IOException | UntrustedIdentityException e) {
-                    logger.warn("Failed to send verification sync message: {}", e.getMessage());
-                }
-            }
-        }
-        account.save();
         return true;
     }
 
@@ -2499,19 +2664,14 @@ public class Manager implements Closeable {
                 theirIdentityKey);
     }
 
-    public SignalServiceAddress canonicalizeAndResolveSignalServiceAddress(String identifier) throws InvalidNumberException {
-        var canonicalizedNumber = UuidUtil.isUuid(identifier)
-                ? identifier
-                : PhoneNumberFormatter.formatNumber(identifier, account.getUsername());
-        return resolveSignalServiceAddress(canonicalizedNumber);
-    }
-
+    @Deprecated
     public SignalServiceAddress resolveSignalServiceAddress(String identifier) {
         var address = Utils.getSignalServiceAddressFromIdentifier(identifier);
 
         return resolveSignalServiceAddress(address);
     }
 
+    @Deprecated
     public SignalServiceAddress resolveSignalServiceAddress(SignalServiceAddress address) {
         if (address.matches(account.getSelfAddress())) {
             return account.getSelfAddress();
@@ -2520,6 +2680,32 @@ public class Manager implements Closeable {
         return account.getRecipientStore().resolveServiceAddress(address);
     }
 
+    public SignalServiceAddress resolveSignalServiceAddress(RecipientId recipientId) {
+        return account.getRecipientStore().resolveServiceAddress(recipientId);
+    }
+
+    public RecipientId canonicalizeAndResolveRecipient(String identifier) throws InvalidNumberException {
+        var canonicalizedNumber = UuidUtil.isUuid(identifier)
+                ? identifier
+                : PhoneNumberFormatter.formatNumber(identifier, account.getUsername());
+
+        return resolveRecipient(canonicalizedNumber);
+    }
+
+    private RecipientId resolveRecipient(final String identifier) {
+        var address = Utils.getSignalServiceAddressFromIdentifier(identifier);
+
+        return resolveRecipient(address);
+    }
+
+    public RecipientId resolveRecipient(SignalServiceAddress address) {
+        return account.getRecipientStore().resolveRecipient(address);
+    }
+
+    private RecipientId resolveRecipientTrusted(SignalServiceAddress address) {
+        return account.getRecipientStore().resolveRecipientTrusted(address);
+    }
+
     @Override
     public void close() throws IOException {
         close(true);