X-Git-Url: https://git.nmode.ca/signal-cli/blobdiff_plain/3643d57d0eaef73d1aa375ad95e97b4cc2dcc12e..4f67ac674b464b07a9ce022a6b19229d511384e2:/lib/src/main/java/org/asamk/signal/manager/Manager.java

diff --git a/lib/src/main/java/org/asamk/signal/manager/Manager.java b/lib/src/main/java/org/asamk/signal/manager/Manager.java
index 4abe1260..cc57e061 100644
--- a/lib/src/main/java/org/asamk/signal/manager/Manager.java
+++ b/lib/src/main/java/org/asamk/signal/manager/Manager.java
@@ -17,19 +17,27 @@
 package org.asamk.signal.manager;
 
 import org.asamk.signal.manager.api.Device;
+import org.asamk.signal.manager.api.TypingAction;
 import org.asamk.signal.manager.config.ServiceConfig;
 import org.asamk.signal.manager.config.ServiceEnvironment;
 import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
 import org.asamk.signal.manager.groups.GroupId;
 import org.asamk.signal.manager.groups.GroupIdV1;
 import org.asamk.signal.manager.groups.GroupInviteLinkUrl;
+import org.asamk.signal.manager.groups.GroupLinkState;
 import org.asamk.signal.manager.groups.GroupNotFoundException;
+import org.asamk.signal.manager.groups.GroupPermission;
 import org.asamk.signal.manager.groups.GroupUtils;
+import org.asamk.signal.manager.groups.LastGroupAdminException;
 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.SendHelper;
 import org.asamk.signal.manager.helper.UnidentifiedAccessHelper;
+import org.asamk.signal.manager.jobs.Context;
+import org.asamk.signal.manager.jobs.Job;
+import org.asamk.signal.manager.jobs.RetrieveStickerPackJob;
 import org.asamk.signal.manager.storage.SignalAccount;
 import org.asamk.signal.manager.storage.groups.GroupInfo;
 import org.asamk.signal.manager.storage.groups.GroupInfoV1;
@@ -58,14 +66,12 @@ import org.signal.libsignal.metadata.ProtocolLegacyMessageException;
 import org.signal.libsignal.metadata.ProtocolNoSessionException;
 import org.signal.libsignal.metadata.ProtocolUntrustedIdentityException;
 import org.signal.libsignal.metadata.SelfSendException;
-import org.signal.libsignal.metadata.certificate.CertificateValidator;
 import org.signal.storageservice.protos.groups.GroupChange;
 import org.signal.storageservice.protos.groups.local.DecryptedGroup;
 import org.signal.zkgroup.InvalidInputException;
 import org.signal.zkgroup.VerificationFailedException;
 import org.signal.zkgroup.groups.GroupMasterKey;
 import org.signal.zkgroup.groups.GroupSecretParams;
-import org.signal.zkgroup.profiles.ClientZkProfileOperations;
 import org.signal.zkgroup.profiles.ProfileKey;
 import org.signal.zkgroup.profiles.ProfileKeyCredential;
 import org.slf4j.Logger;
@@ -75,21 +81,18 @@ import org.whispersystems.libsignal.IdentityKeyPair;
 import org.whispersystems.libsignal.InvalidKeyException;
 import org.whispersystems.libsignal.InvalidMessageException;
 import org.whispersystems.libsignal.ecc.ECPublicKey;
+import org.whispersystems.libsignal.fingerprint.Fingerprint;
+import org.whispersystems.libsignal.fingerprint.FingerprintParsingException;
+import org.whispersystems.libsignal.fingerprint.FingerprintVersionMismatchException;
 import org.whispersystems.libsignal.state.PreKeyRecord;
 import org.whispersystems.libsignal.state.SignedPreKeyRecord;
 import org.whispersystems.libsignal.util.Pair;
 import org.whispersystems.libsignal.util.guava.Optional;
-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.crypto.SignalServiceCipher;
+import org.whispersystems.signalservice.api.InvalidMessageStructureException;
+import org.whispersystems.signalservice.api.SignalSessionLock;
 import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
-import org.whispersystems.signalservice.api.groupsv2.ClientZkOperations;
 import org.whispersystems.signalservice.api.groupsv2.GroupLinkNotActiveException;
-import org.whispersystems.signalservice.api.groupsv2.GroupsV2Api;
 import org.whispersystems.signalservice.api.groupsv2.GroupsV2AuthorizationString;
-import org.whispersystems.signalservice.api.groupsv2.GroupsV2Operations;
 import org.whispersystems.signalservice.api.messages.SendMessageResult;
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachment;
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPointer;
@@ -101,6 +104,7 @@ import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope;
 import org.whispersystems.signalservice.api.messages.SignalServiceGroup;
 import org.whispersystems.signalservice.api.messages.SignalServiceGroupV2;
 import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage;
+import org.whispersystems.signalservice.api.messages.SignalServiceTypingMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.BlockedListMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.ContactsMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.DeviceContact;
@@ -110,21 +114,19 @@ 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.RequestMessage;
-import org.whispersystems.signalservice.api.messages.multidevice.SentTranscriptMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.StickerPackOperationMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage;
 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.ConflictException;
 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;
-import org.whispersystems.signalservice.api.util.UptimeSleepTimer;
 import org.whispersystems.signalservice.api.util.UuidUtil;
+import org.whispersystems.signalservice.api.websocket.WebSocketUnavailableException;
 import org.whispersystems.signalservice.internal.contacts.crypto.Quote;
 import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedQuoteException;
 import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedResponseException;
@@ -161,6 +163,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;
 
@@ -170,29 +173,30 @@ public class Manager implements Closeable {
 
     private final static Logger logger = LoggerFactory.getLogger(Manager.class);
 
-    private final CertificateValidator certificateValidator;
-
     private final ServiceEnvironmentConfig serviceEnvironmentConfig;
-    private final String userAgent;
+    private final SignalDependencies dependencies;
 
     private SignalAccount account;
-    private final SignalServiceAccountManager accountManager;
-    private final GroupsV2Api groupsV2Api;
-    private final GroupsV2Operations groupsV2Operations;
-    private final SignalServiceMessageReceiver messageReceiver;
-    private final ClientZkProfileOperations clientZkProfileOperations;
 
     private final ExecutorService executor = Executors.newCachedThreadPool();
 
-    private SignalServiceMessagePipe messagePipe = null;
-    private SignalServiceMessagePipe unidentifiedMessagePipe = null;
-
-    private final UnidentifiedAccessHelper unidentifiedAccessHelper;
     private final ProfileHelper profileHelper;
-    private final GroupHelper groupHelper;
+    private final GroupV2Helper groupV2Helper;
     private final PinHelper pinHelper;
+    private final SendHelper sendHelper;
+
     private final AvatarStore avatarStore;
     private final AttachmentStore attachmentStore;
+    private final StickerPackStore stickerPackStore;
+    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,
@@ -202,61 +206,47 @@ public class Manager implements Closeable {
     ) {
         this.account = account;
         this.serviceEnvironmentConfig = serviceEnvironmentConfig;
-        this.certificateValidator = new CertificateValidator(serviceEnvironmentConfig.getUnidentifiedSenderTrustRoot());
-        this.userAgent = userAgent;
-        this.groupsV2Operations = capabilities.isGv2() ? new GroupsV2Operations(ClientZkOperations.create(
-                serviceEnvironmentConfig.getSignalServiceConfiguration())) : null;
-        final SleepTimer timer = new UptimeSleepTimer();
-        this.accountManager = new SignalServiceAccountManager(serviceEnvironmentConfig.getSignalServiceConfiguration(),
-                new DynamicCredentialsProvider(account.getUuid(),
-                        account.getUsername(),
-                        account.getPassword(),
-                        account.getDeviceId()),
-                userAgent,
-                groupsV2Operations,
-                ServiceConfig.AUTOMATIC_NETWORK_RETRY,
-                timer);
-        this.groupsV2Api = accountManager.getGroupsV2Api();
-        final var keyBackupService = accountManager.getKeyBackupService(ServiceConfig.getIasKeyStore(),
-                serviceEnvironmentConfig.getKeyBackupConfig().getEnclaveName(),
-                serviceEnvironmentConfig.getKeyBackupConfig().getServiceId(),
-                serviceEnvironmentConfig.getKeyBackupConfig().getMrenclave(),
-                10);
-
-        this.pinHelper = new PinHelper(keyBackupService);
-        this.clientZkProfileOperations = capabilities.isGv2()
-                ? ClientZkOperations.create(serviceEnvironmentConfig.getSignalServiceConfiguration())
-                .getProfileOperations()
-                : null;
-        this.messageReceiver = new SignalServiceMessageReceiver(serviceEnvironmentConfig.getSignalServiceConfiguration(),
-                account.getUuid(),
+
+        final var credentialsProvider = new DynamicCredentialsProvider(account.getUuid(),
                 account.getUsername(),
                 account.getPassword(),
-                account.getDeviceId(),
+                account.getDeviceId());
+        this.dependencies = new SignalDependencies(account.getSelfAddress(),
+                serviceEnvironmentConfig,
                 userAgent,
-                null,
-                timer,
-                clientZkProfileOperations,
-                ServiceConfig.AUTOMATIC_NETWORK_RETRY);
+                credentialsProvider,
+                account.getSignalProtocolStore(),
+                executor,
+                sessionLock);
+        this.pinHelper = new PinHelper(dependencies.getKeyBackupService());
 
-        this.unidentifiedAccessHelper = new UnidentifiedAccessHelper(account::getProfileKey,
+        final var unidentifiedAccessHelper = new UnidentifiedAccessHelper(account::getProfileKey,
                 account.getProfileStore()::getProfileKey,
                 this::getRecipientProfile,
                 this::getSenderCertificate);
         this.profileHelper = new ProfileHelper(account.getProfileStore()::getProfileKey,
                 unidentifiedAccessHelper::getAccessFor,
-                unidentified -> unidentified ? getOrCreateUnidentifiedMessagePipe() : getOrCreateMessagePipe(),
-                () -> messageReceiver,
+                dependencies::getProfileService,
+                dependencies::getMessageReceiver,
                 this::resolveSignalServiceAddress);
-        this.groupHelper = new GroupHelper(this::getRecipientProfileKeyCredential,
+        this.groupV2Helper = new GroupV2Helper(this::getRecipientProfileKeyCredential,
                 this::getRecipientProfile,
                 account::getSelfRecipientId,
-                groupsV2Operations,
-                groupsV2Api,
+                dependencies.getGroupsV2Operations(),
+                dependencies.getGroupsV2Api(),
                 this::getGroupAuthForToday,
                 this::resolveSignalServiceAddress);
         this.avatarStore = new AvatarStore(pathConfig.getAvatarsPath());
         this.attachmentStore = new AttachmentStore(pathConfig.getAttachmentsPath());
+        this.stickerPackStore = new StickerPackStore(pathConfig.getStickerPacksPath());
+        this.sendHelper = new SendHelper(account,
+                dependencies,
+                unidentifiedAccessHelper,
+                this::resolveSignalServiceAddress,
+                this::resolveRecipient,
+                this::handleIdentityFailure,
+                this::getGroup,
+                this::refreshRegisteredUser);
     }
 
     public String getUsername() {
@@ -316,11 +306,22 @@ public class Manager implements Closeable {
     }
 
     public void checkAccountState() throws IOException {
-        if (accountManager.getPreKeysCount() < ServiceConfig.PREKEY_MINIMUM_COUNT) {
+        if (account.getLastReceiveTimestamp() == 0) {
+            logger.warn("The Signal protocol expects that incoming messages are regularly received.");
+        } else {
+            var diffInMilliseconds = System.currentTimeMillis() - account.getLastReceiveTimestamp();
+            long days = TimeUnit.DAYS.convert(diffInMilliseconds, TimeUnit.MILLISECONDS);
+            if (days > 7) {
+                logger.warn(
+                        "Messages have been last received {} days ago. The Signal protocol expects that incoming messages are regularly received.",
+                        days);
+            }
+        }
+        if (dependencies.getAccountManager().getPreKeysCount() < ServiceConfig.PREKEY_MINIMUM_COUNT) {
             refreshPreKeys();
         }
         if (account.getUuid() == null) {
-            account.setUuid(accountManager.getOwnUuid());
+            account.setUuid(dependencies.getAccountManager().getOwnUuid());
         }
         updateAccountAttributes();
     }
@@ -329,30 +330,47 @@ public class Manager implements Closeable {
      * This is used for checking a set of phone numbers for registration on Signal
      *
      * @param numbers The set of phone number in question
-     * @return A map of numbers to booleans. True if registered, false otherwise. Should never be null
+     * @return A map of numbers to canonicalized number and uuid. If a number is not registered the uuid is null.
      * @throws IOException if its unable to get the contacts to check if they're registered
      */
-    public Map<String, Boolean> areUsersRegistered(Set<String> numbers) throws IOException {
+    public Map<String, Pair<String, UUID>> areUsersRegistered(Set<String> numbers) throws IOException {
+        Map<String, String> canonicalizedNumbers = numbers.stream().collect(Collectors.toMap(n -> n, n -> {
+            try {
+                return canonicalizePhoneNumber(n);
+            } catch (InvalidNumberException e) {
+                return "";
+            }
+        }));
+
         // Note "contactDetails" has no optionals. It only gives us info on users who are registered
-        var contactDetails = getRegisteredUsers(numbers);
+        var contactDetails = getRegisteredUsers(canonicalizedNumbers.values()
+                .stream()
+                .filter(s -> !s.isEmpty())
+                .collect(Collectors.toSet()));
 
-        var registeredUsers = contactDetails.keySet();
+        // Store numbers as recipients so we have the number/uuid association
+        contactDetails.forEach((number, uuid) -> resolveRecipientTrusted(new SignalServiceAddress(uuid, number)));
 
-        return numbers.stream().collect(Collectors.toMap(x -> x, registeredUsers::contains));
+        return numbers.stream().collect(Collectors.toMap(n -> n, n -> {
+            final var number = canonicalizedNumbers.get(n);
+            final var uuid = contactDetails.get(number);
+            return new Pair<>(number.isEmpty() ? null : number, uuid);
+        }));
     }
 
     public void updateAccountAttributes() throws IOException {
-        accountManager.setAccountAttributes(account.getEncryptedDeviceName(),
-                null,
-                account.getLocalRegistrationId(),
-                true,
-                // set legacy pin only if no KBS master key is set
-                account.getPinMasterKey() == null ? account.getRegistrationLockPin() : null,
-                account.getPinMasterKey() == null ? null : account.getPinMasterKey().deriveRegistrationLock(),
-                account.getSelfUnidentifiedAccessKey(),
-                account.isUnrestrictedUnidentifiedAccess(),
-                capabilities,
-                account.isDiscoverableByPhoneNumber());
+        dependencies.getAccountManager()
+                .setAccountAttributes(account.getEncryptedDeviceName(),
+                        null,
+                        account.getLocalRegistrationId(),
+                        true,
+                        // set legacy pin only if no KBS master key is set
+                        account.getPinMasterKey() == null ? account.getRegistrationLockPin() : null,
+                        account.getPinMasterKey() == null ? null : account.getPinMasterKey().deriveRegistrationLock(),
+                        account.getSelfUnidentifiedAccessKey(),
+                        account.isUnrestrictedUnidentifiedAccess(),
+                        capabilities,
+                        account.isDiscoverableByPhoneNumber());
     }
 
     /**
@@ -384,12 +402,14 @@ public class Manager implements Closeable {
         try (final var streamDetails = avatar == null
                 ? avatarStore.retrieveProfileAvatar(getSelfAddress())
                 : avatar.isPresent() ? Utils.createStreamDetailsFromFile(avatar.get()) : null) {
-            accountManager.setVersionedProfile(account.getUuid(),
-                    account.getProfileKey(),
-                    newProfile.getInternalServiceName(),
-                    newProfile.getAbout() == null ? "" : newProfile.getAbout(),
-                    newProfile.getAboutEmoji() == null ? "" : newProfile.getAboutEmoji(),
-                    streamDetails);
+            dependencies.getAccountManager()
+                    .setVersionedProfile(account.getUuid(),
+                            account.getProfileKey(),
+                            newProfile.getInternalServiceName(),
+                            newProfile.getAbout() == null ? "" : newProfile.getAbout(),
+                            newProfile.getAboutEmoji() == null ? "" : newProfile.getAboutEmoji(),
+                            Optional.absent(),
+                            streamDetails);
         }
 
         if (avatar != null) {
@@ -402,29 +422,26 @@ public class Manager implements Closeable {
         }
         account.getProfileStore().storeProfile(account.getSelfRecipientId(), newProfile);
 
-        try {
-            sendSyncMessage(SignalServiceSyncMessage.forFetchLatest(SignalServiceSyncMessage.FetchType.LOCAL_PROFILE));
-        } catch (UntrustedIdentityException ignored) {
-        }
+        sendHelper.sendSyncMessage(SignalServiceSyncMessage.forFetchLatest(SignalServiceSyncMessage.FetchType.LOCAL_PROFILE));
     }
 
     public void unregister() throws IOException {
         // When setting an empty GCM id, the Signal-Server also sets the fetchesMessages property to false.
         // 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());
+        dependencies.getAccountManager().setGcmId(Optional.absent());
 
         account.setRegistered(false);
     }
 
     public void deleteAccount() throws IOException {
-        accountManager.deleteAccount();
+        dependencies.getAccountManager().deleteAccount();
 
         account.setRegistered(false);
     }
 
     public List<Device> getLinkedDevices() throws IOException {
-        var devices = accountManager.getDevices();
+        var devices = dependencies.getAccountManager().getDevices();
         account.setMultiDevice(devices.size() > 1);
         var identityKey = account.getIdentityKeyPair().getPrivateKey();
         return devices.stream().map(d -> {
@@ -441,8 +458,8 @@ public class Manager implements Closeable {
     }
 
     public void removeLinkedDevices(int deviceId) throws IOException {
-        accountManager.removeDevice(deviceId);
-        var devices = accountManager.getDevices();
+        dependencies.getAccountManager().removeDevice(deviceId);
+        var devices = dependencies.getAccountManager().getDevices();
         account.setMultiDevice(devices.size() > 1);
     }
 
@@ -454,13 +471,14 @@ public class Manager implements Closeable {
 
     private void addDevice(String deviceIdentifier, ECPublicKey deviceKey) throws IOException, InvalidKeyException {
         var identityKeyPair = getIdentityKeyPair();
-        var verificationCode = accountManager.getNewDeviceVerificationCode();
-
-        accountManager.addDevice(deviceIdentifier,
-                deviceKey,
-                identityKeyPair,
-                Optional.of(account.getProfileKey().serialize()),
-                verificationCode);
+        var verificationCode = dependencies.getAccountManager().getNewDeviceVerificationCode();
+
+        dependencies.getAccountManager()
+                .addDevice(deviceIdentifier,
+                        deviceKey,
+                        identityKeyPair,
+                        Optional.of(account.getProfileKey().serialize()),
+                        verificationCode);
         account.setMultiDevice(true);
     }
 
@@ -477,9 +495,6 @@ public class Manager implements Closeable {
 
             account.setRegistrationLockPin(pin.get(), masterKey);
         } else {
-            // Remove legacy registration lock
-            accountManager.removeRegistrationLockV1();
-
             // Remove KBS Pin
             pinHelper.removeRegistrationLockPin();
 
@@ -492,7 +507,7 @@ public class Manager implements Closeable {
         final var identityKeyPair = getIdentityKeyPair();
         var signedPreKeyRecord = generateSignedPreKey(identityKeyPair);
 
-        accountManager.setPreKeys(identityKeyPair.getPublicKey(), signedPreKeyRecord, oneTimePreKeys);
+        dependencies.getAccountManager().setPreKeys(identityKeyPair.getPublicKey(), signedPreKeyRecord, oneTimePreKeys);
     }
 
     private List<PreKeyRecord> generatePreKeys() {
@@ -513,38 +528,6 @@ public class Manager implements Closeable {
         return record;
     }
 
-    private SignalServiceMessagePipe getOrCreateMessagePipe() {
-        if (messagePipe == null) {
-            messagePipe = messageReceiver.createMessagePipe();
-        }
-        return messagePipe;
-    }
-
-    private SignalServiceMessagePipe getOrCreateUnidentifiedMessagePipe() {
-        if (unidentifiedMessagePipe == null) {
-            unidentifiedMessagePipe = messageReceiver.createUnidentifiedMessagePipe();
-        }
-        return unidentifiedMessagePipe;
-    }
-
-    private SignalServiceMessageSender createMessageSender() {
-        return new SignalServiceMessageSender(serviceEnvironmentConfig.getSignalServiceConfiguration(),
-                account.getUuid(),
-                account.getUsername(),
-                account.getPassword(),
-                account.getDeviceId(),
-                account.getSignalProtocolStore(),
-                userAgent,
-                account.isMultiDevice(),
-                Optional.fromNullable(messagePipe),
-                Optional.fromNullable(unidentifiedMessagePipe),
-                Optional.absent(),
-                clientZkProfileOperations,
-                executor,
-                ServiceConfig.MAX_ENVELOPE_SIZE,
-                ServiceConfig.AUTOMATIC_NETWORK_RETRY);
-    }
-
     public Profile getRecipientProfile(
             RecipientId recipientId
     ) {
@@ -556,17 +539,9 @@ public class Manager implements Closeable {
     Profile getRecipientProfile(
             RecipientId recipientId, boolean force
     ) {
-        var profileKey = account.getProfileStore().getProfileKey(recipientId);
-        if (profileKey == null) {
-            if (force) {
-                // retrieve profile to get identity key
-                retrieveEncryptedProfile(recipientId);
-            }
-            return null;
-        }
         var profile = account.getProfileStore().getProfile(recipientId);
 
-        var now = new Date().getTime();
+        var now = System.currentTimeMillis();
         // Profiles are cached for 24h before retrieving them again, unless forced
         if (!force && profile != null && now - profile.getLastUpdateTimestamp() < 24 * 60 * 60 * 1000) {
             return profile;
@@ -590,12 +565,29 @@ public class Manager implements Closeable {
             return null;
         }
 
-        profile = decryptProfileAndDownloadAvatar(recipientId, profileKey, encryptedProfile);
+        profile = decryptProfileIfKeyKnown(recipientId, encryptedProfile);
         account.getProfileStore().storeProfile(recipientId, profile);
 
         return profile;
     }
 
+    private Profile decryptProfileIfKeyKnown(
+            final RecipientId recipientId, final SignalServiceProfile encryptedProfile
+    ) {
+        var profileKey = account.getProfileStore().getProfileKey(recipientId);
+        if (profileKey == null) {
+            return new Profile(System.currentTimeMillis(),
+                    null,
+                    null,
+                    null,
+                    null,
+                    ProfileUtils.getUnidentifiedAccessMode(encryptedProfile, null),
+                    ProfileUtils.getCapabilities(encryptedProfile));
+        }
+
+        return decryptProfileAndDownloadAvatar(recipientId, profileKey, encryptedProfile);
+    }
+
     private SignalServiceProfile retrieveEncryptedProfile(RecipientId recipientId) {
         try {
             return retrieveProfileAndCredential(recipientId, SignalServiceProfile.RequestType.PROFILE).getProfile();
@@ -622,7 +614,7 @@ public class Manager implements Closeable {
             }
         } catch (InvalidKeyException ignored) {
             logger.warn("Got invalid identity key in profile for {}",
-                    resolveSignalServiceAddress(recipientId).getLegacyIdentifier());
+                    resolveSignalServiceAddress(recipientId).getIdentifier());
         }
         return profileAndCredential;
     }
@@ -684,17 +676,6 @@ public class Manager implements Closeable {
         return Optional.of(AttachmentUtils.createAttachment(streamDetails, Optional.absent()));
     }
 
-    private GroupInfo getGroupForSending(GroupId groupId) throws GroupNotFoundException, NotAGroupMemberException {
-        var g = getGroup(groupId);
-        if (g == null) {
-            throw new GroupNotFoundException(groupId);
-        }
-        if (!g.isMember(account.getSelfRecipientId())) {
-            throw new NotAGroupMemberException(groupId, g.getTitle());
-        }
-        return g;
-    }
-
     private GroupInfo getGroupForUpdating(GroupId groupId) throws GroupNotFoundException, NotAGroupMemberException {
         var g = getGroup(groupId);
         if (g == null) {
@@ -713,12 +694,12 @@ public class Manager implements Closeable {
     public Pair<Long, List<SendMessageResult>> sendGroupMessage(
             String messageText, List<String> attachments, GroupId groupId
     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
-        final var messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
+        final var messageBuilder = createMessageBuilder().withBody(messageText);
         if (attachments != null) {
             messageBuilder.withAttachments(AttachmentUtils.getSignalServiceAttachments(attachments));
         }
 
-        return sendGroupMessage(messageBuilder, groupId);
+        return sendHelper.sendAsGroupMessage(messageBuilder, groupId);
     }
 
     public Pair<Long, List<SendMessageResult>> sendGroupMessageReaction(
@@ -729,131 +710,218 @@ public class Manager implements Closeable {
                 remove,
                 resolveSignalServiceAddress(targetAuthorRecipientId),
                 targetSentTimestamp);
-        final var messageBuilder = SignalServiceDataMessage.newBuilder().withReaction(reaction);
+        final var messageBuilder = createMessageBuilder().withReaction(reaction);
 
-        return sendGroupMessage(messageBuilder, groupId);
+        return sendHelper.sendAsGroupMessage(messageBuilder, groupId);
     }
 
-    public Pair<Long, List<SendMessageResult>> sendGroupMessage(
-            SignalServiceDataMessage.Builder messageBuilder, GroupId groupId
-    ) throws IOException, GroupNotFoundException, NotAGroupMemberException {
-        final var g = getGroupForSending(groupId);
+    public Pair<Long, List<SendMessageResult>> sendQuitGroupMessage(
+            GroupId groupId, Set<String> groupAdmins
+    ) throws GroupNotFoundException, IOException, NotAGroupMemberException, InvalidNumberException, LastGroupAdminException {
+        var group = getGroupForUpdating(groupId);
+        if (group instanceof GroupInfoV1) {
+            return quitGroupV1((GroupInfoV1) group);
+        }
 
-        GroupUtils.setGroupContext(messageBuilder, g);
-        messageBuilder.withExpiration(g.getMessageExpirationTime());
+        final var newAdmins = getRecipientIds(groupAdmins);
+        try {
+            return quitGroupV2((GroupInfoV2) group, newAdmins);
+        } catch (ConflictException e) {
+            // Detected conflicting update, refreshing group and trying again
+            group = getGroup(groupId, true);
+            return quitGroupV2((GroupInfoV2) group, newAdmins);
+        }
+    }
+
+    private Pair<Long, List<SendMessageResult>> quitGroupV1(final GroupInfoV1 groupInfoV1) throws IOException {
+        var group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT)
+                .withId(groupInfoV1.getGroupId().serialize())
+                .build();
 
-        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfRecipientId()));
+        var messageBuilder = createMessageBuilder().asGroupMessage(group);
+        groupInfoV1.removeMember(account.getSelfRecipientId());
+        account.getGroupStore().updateGroup(groupInfoV1);
+        return sendHelper.sendGroupMessage(messageBuilder.build(),
+                groupInfoV1.getMembersIncludingPendingWithout(account.getSelfRecipientId()));
+    }
+
+    private Pair<Long, List<SendMessageResult>> quitGroupV2(
+            final GroupInfoV2 groupInfoV2, final Set<RecipientId> newAdmins
+    ) throws LastGroupAdminException, IOException {
+        final var currentAdmins = groupInfoV2.getAdminMembers();
+        newAdmins.removeAll(currentAdmins);
+        newAdmins.retainAll(groupInfoV2.getMembers());
+        if (currentAdmins.contains(getSelfRecipientId())
+                && currentAdmins.size() == 1
+                && groupInfoV2.getMembers().size() > 1
+                && newAdmins.size() == 0) {
+            // Last admin can't leave the group, unless she's also the last member
+            throw new LastGroupAdminException(groupInfoV2.getGroupId(), groupInfoV2.getTitle());
+        }
+        final var groupGroupChangePair = groupV2Helper.leaveGroup(groupInfoV2, newAdmins);
+        groupInfoV2.setGroup(groupGroupChangePair.first(), this::resolveRecipient);
+        var messageBuilder = getGroupUpdateMessageBuilder(groupInfoV2, groupGroupChangePair.second().toByteArray());
+        account.getGroupStore().updateGroup(groupInfoV2);
+        return sendHelper.sendGroupMessage(messageBuilder.build(),
+                groupInfoV2.getMembersIncludingPendingWithout(account.getSelfRecipientId()));
+    }
+
+    public void deleteGroup(GroupId groupId) throws IOException {
+        account.getGroupStore().deleteGroup(groupId);
+        avatarStore.deleteGroupAvatar(groupId);
+    }
+
+    public Pair<GroupId, List<SendMessageResult>> createGroup(
+            String name, List<String> members, File avatarFile
+    ) throws IOException, AttachmentInvalidException, InvalidNumberException {
+        return createGroup(name, members == null ? null : getRecipientIds(members), avatarFile);
     }
 
-    public Pair<Long, List<SendMessageResult>> sendQuitGroupMessage(GroupId groupId) throws GroupNotFoundException, IOException, NotAGroupMemberException {
-        SignalServiceDataMessage.Builder messageBuilder;
+    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);
+        }
 
-        final var g = getGroupForUpdating(groupId);
-        if (g instanceof GroupInfoV1) {
-            var groupInfoV1 = (GroupInfoV1) g;
-            var group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT).withId(groupId.serialize()).build();
-            messageBuilder = SignalServiceDataMessage.newBuilder().asGroupMessage(group);
-            groupInfoV1.removeMember(account.getSelfRecipientId());
-            account.getGroupStore().updateGroup(groupInfoV1);
-        } else {
-            final var groupInfoV2 = (GroupInfoV2) g;
-            final var groupGroupChangePair = groupHelper.leaveGroup(groupInfoV2);
-            groupInfoV2.setGroup(groupGroupChangePair.first(), this::resolveRecipient);
-            messageBuilder = getGroupUpdateMessageBuilder(groupInfoV2, groupGroupChangePair.second().toByteArray());
-            account.getGroupStore().updateGroup(groupInfoV2);
+        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());
         }
 
-        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfRecipientId()));
-    }
+        final var gv2 = gv2Pair.first();
+        final var decryptedGroup = gv2Pair.second();
 
-    public Pair<GroupId, List<SendMessageResult>> updateGroup(
-            GroupId groupId, String name, List<String> members, File avatarFile
+        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 = sendHelper.sendGroupMessage(messageBuilder.build(),
+                gv2.getMembersIncludingPendingWithout(selfRecipientId));
+        return new Pair<>(gv2.getGroupId(), result.second());
+    }
+
+    public Pair<Long, List<SendMessageResult>> updateGroup(
+            GroupId groupId,
+            String name,
+            String description,
+            List<String> members,
+            List<String> removeMembers,
+            List<String> admins,
+            List<String> removeAdmins,
+            boolean resetGroupLink,
+            GroupLinkState groupLinkState,
+            GroupPermission addMemberPermission,
+            GroupPermission editDetailsPermission,
+            File avatarFile,
+            Integer expirationTimer,
+            Boolean isAnnouncementGroup
     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException {
-        return sendUpdateGroupMessage(groupId,
+        return updateGroup(groupId,
                 name,
-                members == null ? null : getSignalServiceAddresses(members),
-                avatarFile);
-    }
-
-    private Pair<GroupId, List<SendMessageResult>> sendUpdateGroupMessage(
-            GroupId groupId, String name, Set<RecipientId> members, File avatarFile
+                description,
+                members == null ? null : getRecipientIds(members),
+                removeMembers == null ? null : getRecipientIds(removeMembers),
+                admins == null ? null : getRecipientIds(admins),
+                removeAdmins == null ? null : getRecipientIds(removeAdmins),
+                resetGroupLink,
+                groupLinkState,
+                addMemberPermission,
+                editDetailsPermission,
+                avatarFile,
+                expirationTimer,
+                isAnnouncementGroup);
+    }
+
+    private Pair<Long, List<SendMessageResult>> updateGroup(
+            final GroupId groupId,
+            final String name,
+            final String description,
+            final Set<RecipientId> members,
+            final Set<RecipientId> removeMembers,
+            final Set<RecipientId> admins,
+            final Set<RecipientId> removeAdmins,
+            final boolean resetGroupLink,
+            final GroupLinkState groupLinkState,
+            final GroupPermission addMemberPermission,
+            final GroupPermission editDetailsPermission,
+            final File avatarFile,
+            final Integer expirationTimer,
+            final Boolean isAnnouncementGroup
     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
-        GroupInfo g;
-        SignalServiceDataMessage.Builder messageBuilder;
-        if (groupId == null) {
-            // Create new group
-            var gv2Pair = groupHelper.createGroupV2(name == null ? "" : name,
-                    members == null ? Set.of() : members,
-                    avatarFile);
-            if (gv2Pair == null) {
-                var gv1 = new GroupInfoV1(GroupIdV1.createRandom());
-                gv1.addMembers(List.of(account.getSelfRecipientId()));
-                updateGroupV1(gv1, name, members, avatarFile);
-                messageBuilder = getGroupUpdateMessageBuilder(gv1);
-                g = gv1;
-            } else {
-                final var gv2 = gv2Pair.first();
-                final var decryptedGroup = gv2Pair.second();
+        var group = getGroupForUpdating(groupId);
 
-                gv2.setGroup(decryptedGroup, this::resolveRecipient);
-                if (avatarFile != null) {
-                    avatarStore.storeGroupAvatar(gv2.getGroupId(),
-                            outputStream -> IOUtils.copyFileToStream(avatarFile, outputStream));
-                }
-                messageBuilder = getGroupUpdateMessageBuilder(gv2, null);
-                g = gv2;
+        if (group instanceof GroupInfoV2) {
+            try {
+                return updateGroupV2((GroupInfoV2) group,
+                        name,
+                        description,
+                        members,
+                        removeMembers,
+                        admins,
+                        removeAdmins,
+                        resetGroupLink,
+                        groupLinkState,
+                        addMemberPermission,
+                        editDetailsPermission,
+                        avatarFile,
+                        expirationTimer,
+                        isAnnouncementGroup);
+            } catch (ConflictException e) {
+                // Detected conflicting update, refreshing group and trying again
+                group = getGroup(groupId, true);
+                return updateGroupV2((GroupInfoV2) group,
+                        name,
+                        description,
+                        members,
+                        removeMembers,
+                        admins,
+                        removeAdmins,
+                        resetGroupLink,
+                        groupLinkState,
+                        addMemberPermission,
+                        editDetailsPermission,
+                        avatarFile,
+                        expirationTimer,
+                        isAnnouncementGroup);
             }
-        } else {
-            var group = getGroupForUpdating(groupId);
-            if (group instanceof GroupInfoV2) {
-                final var groupInfoV2 = (GroupInfoV2) group;
-
-                Pair<Long, List<SendMessageResult>> result = null;
-                if (groupInfoV2.isPendingMember(account.getSelfRecipientId())) {
-                    var groupGroupChangePair = groupHelper.acceptInvite(groupInfoV2);
-                    result = sendUpdateGroupMessage(groupInfoV2,
-                            groupGroupChangePair.first(),
-                            groupGroupChangePair.second());
-                }
-
-                if (members != null) {
-                    final var newMembers = new HashSet<>(members);
-                    newMembers.removeAll(group.getMembers());
-                    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;
-            }
+        final var gv1 = (GroupInfoV1) group;
+        final var result = updateGroupV1(gv1, name, members, avatarFile);
+        if (expirationTimer != null) {
+            setExpirationTimer(gv1, expirationTimer);
         }
+        return result;
+    }
+
+    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(g);
+        account.getGroupStore().updateGroup(gv1);
 
-        final var result = sendMessage(messageBuilder,
-                g.getMembersIncludingPendingWithout(account.getSelfRecipientId()));
-        return new Pair<>(g.getGroupId(), result.second());
+        return sendHelper.sendGroupMessage(messageBuilder.build(),
+                gv1.getMembersIncludingPendingWithout(account.getSelfRecipientId()));
     }
 
-    private void updateGroupV1(
+    private void updateGroupV1Details(
             final GroupInfoV1 g, final String name, final Collection<RecipientId> members, final File avatarFile
     ) throws IOException {
         if (name != null) {
@@ -891,18 +959,129 @@ 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 Set<RecipientId> admins,
+            final Set<RecipientId> removeAdmins,
+            final boolean resetGroupLink,
+            final GroupLinkState groupLinkState,
+            final GroupPermission addMemberPermission,
+            final GroupPermission editDetailsPermission,
+            final File avatarFile,
+            final Integer expirationTimer,
+            final Boolean isAnnouncementGroup
+    ) 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 (admins != null) {
+            final var newAdmins = new HashSet<>(admins);
+            newAdmins.retainAll(group.getMembers());
+            newAdmins.removeAll(group.getAdminMembers());
+            if (newAdmins.size() > 0) {
+                for (var admin : newAdmins) {
+                    var groupGroupChangePair = groupV2Helper.setMemberAdmin(group, admin, true);
+                    result = sendUpdateGroupV2Message(group,
+                            groupGroupChangePair.first(),
+                            groupGroupChangePair.second());
+                }
+            }
+        }
+
+        if (removeAdmins != null) {
+            final var existingRemoveAdmins = new HashSet<>(removeAdmins);
+            existingRemoveAdmins.retainAll(group.getAdminMembers());
+            if (existingRemoveAdmins.size() > 0) {
+                for (var admin : existingRemoveAdmins) {
+                    var groupGroupChangePair = groupV2Helper.setMemberAdmin(group, admin, false);
+                    result = sendUpdateGroupV2Message(group,
+                            groupGroupChangePair.first(),
+                            groupGroupChangePair.second());
+                }
+            }
+        }
+
+        if (resetGroupLink) {
+            var groupGroupChangePair = groupV2Helper.resetGroupLinkPassword(group);
+            result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+        }
+
+        if (groupLinkState != null) {
+            var groupGroupChangePair = groupV2Helper.setGroupLinkState(group, groupLinkState);
+            result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+        }
+
+        if (addMemberPermission != null) {
+            var groupGroupChangePair = groupV2Helper.setAddMemberPermission(group, addMemberPermission);
+            result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+        }
+
+        if (editDetailsPermission != null) {
+            var groupGroupChangePair = groupV2Helper.setEditDetailsPermission(group, editDetailsPermission);
+            result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+        }
+
+        if (expirationTimer != null) {
+            var groupGroupChangePair = groupV2Helper.setMessageExpirationTimer(group, expirationTimer);
+            result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+        }
+
+        if (isAnnouncementGroup != null) {
+            var groupGroupChangePair = groupV2Helper.setIsAnnouncementGroup(group, isAnnouncementGroup);
+            result = sendUpdateGroupV2Message(group, groupGroupChangePair.first(), groupGroupChangePair.second());
+        }
+
+        if (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(),
@@ -914,11 +1093,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 sendHelper.sendGroupMessage(messageBuilder.build(), members);
+    }
+
     private static int currentTimeDays() {
         return (int) TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
     }
@@ -928,35 +1120,27 @@ public class Manager implements Closeable {
     ) throws IOException {
         final var today = currentTimeDays();
         // Returns credentials for the next 7 days
-        final var credentials = groupsV2Api.getCredentials(today);
+        final var credentials = dependencies.getGroupsV2Api().getCredentials(today);
         // TODO cache credentials until they expire
         var authCredentialResponse = credentials.get(today);
         try {
-            return groupsV2Api.getGroupsV2AuthorizationString(account.getUuid(),
-                    today,
-                    groupSecretParams,
-                    authCredentialResponse);
+            return dependencies.getGroupsV2Api()
+                    .getGroupsV2AuthorizationString(account.getUuid(),
+                            today,
+                            groupSecretParams,
+                            authCredentialResponse);
         } catch (VerificationFailedException e) {
             throw new IOException(e);
         }
     }
 
-    private Pair<Long, List<SendMessageResult>> sendUpdateGroupMessage(
-            GroupInfoV2 group, DecryptedGroup newDecryptedGroup, GroupChange groupChange
-    ) throws IOException {
-        group.setGroup(newDecryptedGroup, this::resolveRecipient);
-        final var messageBuilder = getGroupUpdateMessageBuilder(group, groupChange.toByteArray());
-        account.getGroupStore().updateGroup(group);
-        return sendMessage(messageBuilder, group.getMembersIncludingPendingWithout(account.getSelfRecipientId()));
-    }
-
     Pair<Long, List<SendMessageResult>> sendGroupInfoMessage(
             GroupIdV1 groupId, SignalServiceAddress recipient
     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException {
         GroupInfoV1 g;
-        var group = getGroupForSending(groupId);
+        var group = getGroupForUpdating(groupId);
         if (!(group instanceof GroupInfoV1)) {
-            throw new RuntimeException("Received an invalid group request for a v2 group!");
+            throw new IOException("Received an invalid group request for a v2 group!");
         }
         g = (GroupInfoV1) group;
 
@@ -968,7 +1152,7 @@ public class Manager implements Closeable {
         var messageBuilder = getGroupUpdateMessageBuilder(g);
 
         // Send group message only to the recipient who requested it
-        return sendMessage(messageBuilder, Set.of(recipientId));
+        return sendHelper.sendGroupMessage(messageBuilder.build(), Set.of(recipientId));
     }
 
     private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfoV1 g) throws AttachmentInvalidException {
@@ -989,18 +1173,14 @@ public class Manager implements Closeable {
             throw new AttachmentInvalidException(g.getGroupId().toBase64(), e);
         }
 
-        return SignalServiceDataMessage.newBuilder()
-                .asGroupMessage(group.build())
-                .withExpiration(g.getMessageExpirationTime());
+        return createMessageBuilder().asGroupMessage(group.build()).withExpiration(g.getMessageExpirationTime());
     }
 
     private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfoV2 g, byte[] signedGroupChange) {
         var group = SignalServiceGroupV2.newBuilder(g.getMasterKey())
                 .withRevision(g.getGroup().getRevision())
                 .withSignedGroupChange(signedGroupChange);
-        return SignalServiceDataMessage.newBuilder()
-                .asGroupMessage(group.build())
-                .withExpiration(g.getMessageExpirationTime());
+        return createMessageBuilder().asGroupMessage(group.build()).withExpiration(g.getMessageExpirationTime());
     }
 
     Pair<Long, List<SendMessageResult>> sendGroupInfoRequest(
@@ -1008,33 +1188,51 @@ public class Manager implements Closeable {
     ) throws IOException {
         var group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.REQUEST_INFO).withId(groupId.serialize());
 
-        var messageBuilder = SignalServiceDataMessage.newBuilder().asGroupMessage(group.build());
+        var messageBuilder = createMessageBuilder().asGroupMessage(group.build());
 
         // Send group info request message to the recipient who sent us a message with this groupId
-        return sendMessage(messageBuilder, Set.of(resolveRecipient(recipient)));
+        return sendHelper.sendGroupMessage(messageBuilder.build(), Set.of(resolveRecipient(recipient)));
+    }
+
+    public void sendReadReceipt(
+            String sender, List<Long> messageIds
+    ) throws IOException, UntrustedIdentityException, InvalidNumberException {
+        var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.READ,
+                messageIds,
+                System.currentTimeMillis());
+
+        sendHelper.sendReceiptMessage(receiptMessage, canonicalizeAndResolveRecipient(sender));
     }
 
-    void sendReceipt(
-            SignalServiceAddress remoteAddress, long messageId
+    public void sendViewedReceipt(
+            String sender, List<Long> messageIds
+    ) throws IOException, UntrustedIdentityException, InvalidNumberException {
+        var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.VIEWED,
+                messageIds,
+                System.currentTimeMillis());
+
+        sendHelper.sendReceiptMessage(receiptMessage, canonicalizeAndResolveRecipient(sender));
+    }
+
+    void sendDeliveryReceipt(
+            SignalServiceAddress remoteAddress, List<Long> messageIds
     ) throws IOException, UntrustedIdentityException {
         var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.DELIVERY,
-                List.of(messageId),
+                messageIds,
                 System.currentTimeMillis());
 
-        createMessageSender().sendReceipt(remoteAddress,
-                unidentifiedAccessHelper.getAccessFor(resolveRecipient(remoteAddress)),
-                receiptMessage);
+        sendHelper.sendReceiptMessage(receiptMessage, resolveRecipient(remoteAddress));
     }
 
     public Pair<Long, List<SendMessageResult>> sendMessage(
             String messageText, List<String> attachments, List<String> recipients
     ) throws IOException, AttachmentInvalidException, InvalidNumberException {
-        final var messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
+        final var messageBuilder = createMessageBuilder().withBody(messageText);
         if (attachments != null) {
             var attachmentStreams = AttachmentUtils.getSignalServiceAttachments(attachments);
 
             // Upload attachments here, so we only upload once even for multiple recipients
-            var messageSender = createMessageSender();
+            var messageSender = dependencies.getMessageSender();
             var attachmentPointers = new ArrayList<SignalServiceAttachment>(attachmentStreams.size());
             for (var attachment : attachmentStreams) {
                 if (attachment.isStream()) {
@@ -1046,33 +1244,33 @@ public class Manager implements Closeable {
 
             messageBuilder.withAttachments(attachmentPointers);
         }
-        return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));
+        return sendHelper.sendMessage(messageBuilder, getRecipientIds(recipients));
     }
 
     public Pair<Long, SendMessageResult> sendSelfMessage(
             String messageText, List<String> attachments
     ) throws IOException, AttachmentInvalidException {
-        final var messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
+        final var messageBuilder = createMessageBuilder().withBody(messageText);
         if (attachments != null) {
             messageBuilder.withAttachments(AttachmentUtils.getSignalServiceAttachments(attachments));
         }
-        return sendSelfMessage(messageBuilder);
+        return sendHelper.sendSelfMessage(messageBuilder);
     }
 
     public Pair<Long, List<SendMessageResult>> sendRemoteDeleteMessage(
             long targetSentTimestamp, List<String> recipients
     ) throws IOException, InvalidNumberException {
         var delete = new SignalServiceDataMessage.RemoteDelete(targetSentTimestamp);
-        final var messageBuilder = SignalServiceDataMessage.newBuilder().withRemoteDelete(delete);
-        return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));
+        final var messageBuilder = createMessageBuilder().withRemoteDelete(delete);
+        return sendHelper.sendMessage(messageBuilder, getRecipientIds(recipients));
     }
 
     public Pair<Long, List<SendMessageResult>> sendGroupRemoteDeleteMessage(
             long targetSentTimestamp, GroupId groupId
     ) throws IOException, NotAGroupMemberException, GroupNotFoundException {
         var delete = new SignalServiceDataMessage.RemoteDelete(targetSentTimestamp);
-        final var messageBuilder = SignalServiceDataMessage.newBuilder().withRemoteDelete(delete);
-        return sendGroupMessage(messageBuilder, groupId);
+        final var messageBuilder = createMessageBuilder().withRemoteDelete(delete);
+        return sendHelper.sendAsGroupMessage(messageBuilder, groupId);
     }
 
     public Pair<Long, List<SendMessageResult>> sendMessageReaction(
@@ -1083,32 +1281,28 @@ public class Manager implements Closeable {
                 remove,
                 resolveSignalServiceAddress(targetAuthorRecipientId),
                 targetSentTimestamp);
-        final var messageBuilder = SignalServiceDataMessage.newBuilder().withReaction(reaction);
-        return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));
+        final var messageBuilder = createMessageBuilder().withReaction(reaction);
+        return sendHelper.sendMessage(messageBuilder, getRecipientIds(recipients));
     }
 
     public Pair<Long, List<SendMessageResult>> sendEndSessionMessage(List<String> recipients) throws IOException, InvalidNumberException {
-        var messageBuilder = SignalServiceDataMessage.newBuilder().asEndSessionMessage();
+        var messageBuilder = createMessageBuilder().asEndSessionMessage();
 
-        final var signalServiceAddresses = getSignalServiceAddresses(recipients);
+        final var recipientIds = getRecipientIds(recipients);
         try {
-            return sendMessage(messageBuilder, signalServiceAddresses);
-        } catch (Exception e) {
-            for (var address : signalServiceAddresses) {
-                handleEndSession(address);
+            return sendHelper.sendMessage(messageBuilder, recipientIds);
+        } finally {
+            for (var recipientId : recipientIds) {
+                handleEndSession(recipientId);
             }
-            throw e;
         }
     }
 
-    SendMessageResult renewSession(RecipientId recipientId) throws IOException {
+    void renewSession(RecipientId recipientId) throws IOException {
         account.getSessionStore().archiveSessions(recipientId);
-        return sendNullMessage(recipientId);
-    }
-
-    public String getContactName(String number) throws InvalidNumberException {
-        var contact = account.getContactStore().getContact(canonicalizeAndResolveRecipient(number));
-        return contact == null || contact.getName() == null ? "" : contact.getName();
+        if (!recipientId.equals(getSelfRecipientId())) {
+            sendHelper.sendNullMessage(recipientId);
+        }
     }
 
     public void setContactName(String number, String name) throws InvalidNumberException, NotMasterDeviceException {
@@ -1157,8 +1351,8 @@ public class Manager implements Closeable {
     }
 
     private void sendExpirationTimerUpdate(RecipientId recipientId) throws IOException {
-        final var messageBuilder = SignalServiceDataMessage.newBuilder().asExpirationUpdate();
-        sendMessage(messageBuilder, Set.of(recipientId));
+        final var messageBuilder = createMessageBuilder().asExpirationUpdate();
+        sendHelper.sendMessage(messageBuilder, Set.of(recipientId));
     }
 
     /**
@@ -1175,15 +1369,17 @@ public class Manager implements Closeable {
     /**
      * Change the expiration timer for a group
      */
-    public void setExpirationTimer(GroupId groupId, int messageExpirationTimer) {
-        var g = getGroup(groupId);
-        if (g instanceof GroupInfoV1) {
-            var groupInfoV1 = (GroupInfoV1) g;
-            groupInfoV1.messageExpirationTime = messageExpirationTimer;
-            account.getGroupStore().updateGroup(groupInfoV1);
-        } else {
-            throw new RuntimeException("TODO Not implemented!");
-        }
+    private void setExpirationTimer(
+            GroupInfoV1 groupInfoV1, int messageExpirationTimer
+    ) throws NotAGroupMemberException, GroupNotFoundException, IOException {
+        groupInfoV1.messageExpirationTime = messageExpirationTimer;
+        account.getGroupStore().updateGroup(groupInfoV1);
+        sendExpirationTimerUpdate(groupInfoV1.getGroupId());
+    }
+
+    private void sendExpirationTimerUpdate(GroupIdV1 groupId) throws IOException, NotAGroupMemberException, GroupNotFoundException {
+        final var messageBuilder = createMessageBuilder().asExpirationUpdate();
+        sendHelper.sendAsGroupMessage(messageBuilder, groupId);
     }
 
     /**
@@ -1195,21 +1391,23 @@ public class Manager implements Closeable {
     public String uploadStickerPack(File path) throws IOException, StickerPackInvalidException {
         var manifest = StickerUtils.getSignalServiceStickerManifestUpload(path);
 
-        var messageSender = createMessageSender();
+        var messageSender = dependencies.getMessageSender();
 
         var packKey = KeyUtils.createStickerUploadKey();
-        var packId = messageSender.uploadStickerManifest(manifest, packKey);
+        var packIdString = messageSender.uploadStickerManifest(manifest, packKey);
+        var packId = StickerPackId.deserialize(Hex.fromStringCondensed(packIdString));
 
-        var sticker = new Sticker(StickerPackId.deserialize(Hex.fromStringCondensed(packId)), packKey);
+        var sticker = new Sticker(packId, packKey);
         account.getStickerStore().updateSticker(sticker);
 
         try {
             return new URI("https",
                     "signal.art",
                     "/addstickers/",
-                    "pack_id=" + URLEncoder.encode(packId, StandardCharsets.UTF_8) + "&pack_key=" + URLEncoder.encode(
-                            Hex.toStringCondensed(packKey),
-                            StandardCharsets.UTF_8)).toString();
+                    "pack_id="
+                            + URLEncoder.encode(Hex.toStringCondensed(packId.serialize()), StandardCharsets.UTF_8)
+                            + "&pack_key="
+                            + URLEncoder.encode(Hex.toStringCondensed(packKey), StandardCharsets.UTF_8)).toString();
         } catch (URISyntaxException e) {
             throw new AssertionError(e);
         }
@@ -1228,11 +1426,7 @@ public class Manager implements Closeable {
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.GROUPS)
                 .build();
         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
-        try {
-            sendSyncMessage(message);
-        } catch (UntrustedIdentityException e) {
-            throw new AssertionError(e);
-        }
+        sendHelper.sendSyncMessage(message);
     }
 
     private void requestSyncContacts() throws IOException {
@@ -1240,11 +1434,7 @@ public class Manager implements Closeable {
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.CONTACTS)
                 .build();
         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
-        try {
-            sendSyncMessage(message);
-        } catch (UntrustedIdentityException e) {
-            throw new AssertionError(e);
-        }
+        sendHelper.sendSyncMessage(message);
     }
 
     private void requestSyncBlocked() throws IOException {
@@ -1252,11 +1442,7 @@ public class Manager implements Closeable {
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.BLOCKED)
                 .build();
         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
-        try {
-            sendSyncMessage(message);
-        } catch (UntrustedIdentityException e) {
-            throw new AssertionError(e);
-        }
+        sendHelper.sendSyncMessage(message);
     }
 
     private void requestSyncConfiguration() throws IOException {
@@ -1264,11 +1450,7 @@ public class Manager implements Closeable {
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.CONFIGURATION)
                 .build();
         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
-        try {
-            sendSyncMessage(message);
-        } catch (UntrustedIdentityException e) {
-            throw new AssertionError(e);
-        }
+        sendHelper.sendSyncMessage(message);
     }
 
     private void requestSyncKeys() throws IOException {
@@ -1276,20 +1458,16 @@ public class Manager implements Closeable {
                 .setType(SignalServiceProtos.SyncMessage.Request.Type.KEYS)
                 .build();
         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
-        try {
-            sendSyncMessage(message);
-        } catch (UntrustedIdentityException e) {
-            throw new AssertionError(e);
-        }
+        sendHelper.sendSyncMessage(message);
     }
 
     private byte[] getSenderCertificate() {
         byte[] certificate;
         try {
             if (account.isPhoneNumberShared()) {
-                certificate = accountManager.getSenderCertificate();
+                certificate = dependencies.getAccountManager().getSenderCertificate();
             } else {
-                certificate = accountManager.getSenderCertificateForPhoneNumberPrivacy();
+                certificate = dependencies.getAccountManager().getSenderCertificateForPhoneNumberPrivacy();
             }
         } catch (IOException e) {
             logger.warn("Failed to get sender certificate, ignoring: {}", e.getMessage());
@@ -1299,12 +1477,7 @@ public class Manager implements Closeable {
         return certificate;
     }
 
-    private void sendSyncMessage(SignalServiceSyncMessage message) throws IOException, UntrustedIdentityException {
-        var messageSender = createMessageSender();
-        messageSender.sendMessage(message, unidentifiedAccessHelper.getAccessForSync());
-    }
-
-    private Set<RecipientId> getSignalServiceAddresses(Collection<String> numbers) throws InvalidNumberException {
+    private Set<RecipientId> getRecipientIds(Collection<String> numbers) throws InvalidNumberException {
         final var signalServiceAddresses = new HashSet<SignalServiceAddress>(numbers.size());
         final var addressesMissingUuid = new HashSet<SignalServiceAddress>();
 
@@ -1355,168 +1528,43 @@ public class Manager implements Closeable {
 
     private Map<String, UUID> getRegisteredUsers(final Set<String> numbers) throws IOException {
         try {
-            return accountManager.getRegisteredUsers(ServiceConfig.getIasKeyStore(),
-                    numbers,
-                    serviceEnvironmentConfig.getCdsMrenclave());
+            return dependencies.getAccountManager()
+                    .getRegisteredUsers(ServiceConfig.getIasKeyStore(),
+                            numbers,
+                            serviceEnvironmentConfig.getCdsMrenclave());
         } catch (Quote.InvalidQuoteFormatException | UnauthenticatedQuoteException | SignatureException | UnauthenticatedResponseException | InvalidKeyException e) {
             throw new IOException(e);
         }
     }
 
-    private Pair<Long, List<SendMessageResult>> sendMessage(
-            SignalServiceDataMessage.Builder messageBuilder, Set<RecipientId> recipientIds
-    ) throws IOException {
+    public void sendTypingMessage(
+            TypingAction action, Set<String> recipients
+    ) throws IOException, UntrustedIdentityException, InvalidNumberException {
         final var timestamp = System.currentTimeMillis();
-        messageBuilder.withTimestamp(timestamp);
-        getOrCreateMessagePipe();
-        getOrCreateUnidentifiedMessagePipe();
-        SignalServiceDataMessage message = null;
-        try {
-            message = messageBuilder.build();
-            if (message.getGroupContext().isPresent()) {
-                try {
-                    var messageSender = createMessageSender();
-                    final var isRecipientUpdate = false;
-                    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) {
-                            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) {
-                    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>(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(recipientId, message));
-                }
-                return new Pair<>(timestamp, results);
-            }
-        } finally {
-            if (message != null && message.isEndSession()) {
-                for (var recipient : recipientIds) {
-                    handleEndSession(recipient);
-                }
-            }
-        }
+        var message = new SignalServiceTypingMessage(action.toSignalService(), timestamp, Optional.absent());
+        sendHelper.sendTypingMessage(message, getRecipientIds(recipients));
     }
 
-    private Pair<Long, SendMessageResult> sendSelfMessage(
-            SignalServiceDataMessage.Builder messageBuilder
-    ) throws IOException {
+    public void sendGroupTypingMessage(
+            TypingAction action, GroupId groupId
+    ) throws IOException, NotAGroupMemberException, GroupNotFoundException {
         final var timestamp = System.currentTimeMillis();
-        messageBuilder.withTimestamp(timestamp);
-        getOrCreateMessagePipe();
-        getOrCreateUnidentifiedMessagePipe();
-        final var recipientId = account.getSelfRecipientId();
-
-        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);
-    }
-
-    private SendMessageResult sendSelfMessage(SignalServiceDataMessage message) throws IOException {
-        var messageSender = createMessageSender();
-
-        var recipientId = account.getSelfRecipientId();
-
-        final var unidentifiedAccess = unidentifiedAccessHelper.getAccessFor(recipientId);
-        var recipient = resolveSignalServiceAddress(recipientId);
-        var transcript = new SentTranscriptMessage(Optional.of(recipient),
-                message.getTimestamp(),
-                message,
-                message.getExpiresInSeconds(),
-                Map.of(recipient, unidentifiedAccess.isPresent()),
-                false);
-        var syncMessage = SignalServiceSyncMessage.forSentTranscript(transcript);
-
-        try {
-            var startTime = System.currentTimeMillis();
-            messageSender.sendMessage(syncMessage, unidentifiedAccess);
-            return SendMessageResult.success(recipient,
-                    unidentifiedAccess.isPresent(),
-                    false,
-                    System.currentTimeMillis() - startTime);
-        } catch (UntrustedIdentityException e) {
-            return SendMessageResult.identityFailure(recipient, e.getIdentityKey());
-        }
-    }
-
-    private SendMessageResult sendMessage(
-            RecipientId recipientId, SignalServiceDataMessage message
-    ) throws IOException {
-        var messageSender = createMessageSender();
-
-        final var address = resolveSignalServiceAddress(recipientId);
-        try {
-            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) {
-            return SendMessageResult.identityFailure(address, e.getIdentityKey());
-        }
+        final var message = new SignalServiceTypingMessage(action.toSignalService(),
+                timestamp,
+                Optional.of(groupId.serialize()));
+        sendHelper.sendGroupTypingMessage(message, groupId);
     }
 
-    private SendMessageResult sendNullMessage(RecipientId recipientId) throws IOException {
-        var messageSender = createMessageSender();
+    private SignalServiceDataMessage.Builder createMessageBuilder() {
+        final var timestamp = System.currentTimeMillis();
 
-        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());
-        }
+        var messageBuilder = SignalServiceDataMessage.newBuilder();
+        messageBuilder.withTimestamp(timestamp);
+        return messageBuilder;
     }
 
-    private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws InvalidMetadataMessageException, ProtocolInvalidMessageException, ProtocolDuplicateMessageException, ProtocolLegacyMessageException, ProtocolInvalidKeyIdException, InvalidMetadataVersionException, ProtocolInvalidVersionException, ProtocolNoSessionException, ProtocolInvalidKeyException, SelfSendException, UnsupportedDataMessageException, org.whispersystems.libsignal.UntrustedIdentityException {
-        var cipher = new SignalServiceCipher(account.getSelfAddress(),
-                account.getSignalProtocolStore(),
-                certificateValidator);
-        try {
-            return cipher.decrypt(envelope);
-        } catch (ProtocolUntrustedIdentityException e) {
-            if (e.getCause() instanceof org.whispersystems.libsignal.UntrustedIdentityException) {
-                throw (org.whispersystems.libsignal.UntrustedIdentityException) e.getCause();
-            }
-            throw new AssertionError(e);
-        }
+    private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws InvalidMetadataMessageException, ProtocolInvalidMessageException, ProtocolDuplicateMessageException, ProtocolLegacyMessageException, ProtocolInvalidKeyIdException, InvalidMetadataVersionException, ProtocolInvalidVersionException, ProtocolNoSessionException, ProtocolInvalidKeyException, SelfSendException, UnsupportedDataMessageException, ProtocolUntrustedIdentityException, InvalidMessageStructureException {
+        return dependencies.getCipher().decrypt(envelope);
     }
 
     private void handleEndSession(RecipientId recipientId) {
@@ -1670,6 +1718,7 @@ public class Manager implements Closeable {
                 sticker = new Sticker(stickerPackId, messageSticker.getPackKey());
                 account.getStickerStore().updateSticker(sticker);
             }
+            enqueueJob(new RetrieveStickerPackJob(stickerPackId, messageSticker.getPackKey()));
         }
         return actions;
     }
@@ -1700,10 +1749,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);
@@ -1743,6 +1794,9 @@ public class Manager implements Closeable {
             try {
                 action.execute(this);
             } catch (Throwable e) {
+                if (e instanceof AssertionError && e.getCause() instanceof InterruptedException) {
+                    Thread.currentThread().interrupt();
+                }
                 logger.warn("Message action failed.", e);
             }
         }
@@ -1760,9 +1814,9 @@ public class Manager implements Closeable {
         if (!envelope.isReceipt()) {
             try {
                 content = decryptMessage(envelope);
-            } catch (org.whispersystems.libsignal.UntrustedIdentityException e) {
+            } catch (ProtocolUntrustedIdentityException e) {
                 if (!envelope.hasSource()) {
-                    final var identifier = ((org.whispersystems.libsignal.UntrustedIdentityException) e).getName();
+                    final var identifier = e.getSender();
                     final var recipientId = resolveRecipient(identifier);
                     try {
                         account.getMessageCache().replaceSender(cachedMessage, recipientId);
@@ -1789,49 +1843,63 @@ public class Manager implements Closeable {
             boolean returnOnTimeout,
             boolean ignoreAttachments,
             ReceiveMessageHandler handler
-    ) throws IOException {
+    ) throws IOException, InterruptedException {
         retryFailedReceivedMessages(handler, ignoreAttachments);
 
-        Set<HandleAction> queuedActions = null;
+        Set<HandleAction> queuedActions = new HashSet<>();
 
-        final var messagePipe = getOrCreateMessagePipe();
+        final var signalWebSocket = dependencies.getSignalWebSocket();
+        signalWebSocket.connect();
 
         var hasCaughtUpWithOldMessages = false;
 
-        while (true) {
+        while (!Thread.interrupted()) {
             SignalServiceEnvelope envelope;
             SignalServiceContent content = null;
             Exception exception = null;
             final CachedMessage[] cachedMessage = {null};
+            account.setLastReceiveTimestamp(System.currentTimeMillis());
+            logger.debug("Checking for new message from server");
             try {
-                var result = messagePipe.readOrEmpty(timeout, unit, envelope1 -> {
+                var result = signalWebSocket.readOrEmpty(unit.toMillis(timeout), 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, recipientId);
                 });
+                logger.debug("New message received from server");
                 if (result.isPresent()) {
                     envelope = result.get();
                 } else {
                     // Received indicator that server queue is empty
                     hasCaughtUpWithOldMessages = true;
 
-                    if (queuedActions != null) {
-                        for (var action : queuedActions) {
-                            try {
-                                action.execute(this);
-                            } catch (Throwable e) {
-                                logger.warn("Message action failed.", e);
+                    for (var action : queuedActions) {
+                        try {
+                            action.execute(this);
+                        } catch (Throwable e) {
+                            if (e instanceof AssertionError && e.getCause() instanceof InterruptedException) {
+                                Thread.currentThread().interrupt();
                             }
+                            logger.warn("Message action failed.", e);
                         }
-                        queuedActions.clear();
-                        queuedActions = null;
                     }
+                    queuedActions.clear();
 
                     // Continue to wait another timeout for new messages
                     continue;
                 }
+            } catch (AssertionError e) {
+                if (e.getCause() instanceof InterruptedException) {
+                    throw (InterruptedException) e.getCause();
+                } else {
+                    throw e;
+                }
+            } catch (WebSocketUnavailableException e) {
+                logger.debug("Pipe unexpectedly unavailable, connecting");
+                signalWebSocket.connect();
+                continue;
             } catch (TimeoutException e) {
                 if (returnOnTimeout) return;
                 continue;
@@ -1839,15 +1907,20 @@ public class Manager implements Closeable {
 
             if (envelope.hasSource()) {
                 // Store uuid if we don't have it already
+                // 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());
@@ -1859,26 +1932,29 @@ public class Manager implements Closeable {
                         try {
                             action.execute(this);
                         } catch (Throwable e) {
+                            if (e instanceof AssertionError && e.getCause() instanceof InterruptedException) {
+                                Thread.currentThread().interrupt();
+                            }
                             logger.warn("Message action failed.", e);
                         }
                     }
                 } else {
-                    if (queuedActions == null) {
-                        queuedActions = new HashSet<>();
-                    }
                     queuedActions.addAll(actions);
                 }
             }
+            final var notAllowedToSendToGroup = isNotAllowedToSendToGroup(envelope, content);
             if (isMessageBlocked(envelope, content)) {
                 logger.info("Ignoring a message from blocked user/group: {}", envelope.getTimestamp());
-            } else if (notAGroupMember) {
-                logger.info("Ignoring a message from a non group member: {}", envelope.getTimestamp());
+            } else if (notAllowedToSendToGroup) {
+                logger.info("Ignoring a group message from an unauthorized sender (no member or admin): {} {}",
+                        (envelope.hasSource() ? envelope.getSourceAddress() : content.getSender()).getIdentifier(),
+                        envelope.getTimestamp());
             } else {
                 handler.handleMessage(envelope, content, exception);
             }
             if (cachedMessage[0] != null) {
-                if (exception instanceof org.whispersystems.libsignal.UntrustedIdentityException) {
-                    final var identifier = ((org.whispersystems.libsignal.UntrustedIdentityException) exception).getName();
+                if (exception instanceof ProtocolUntrustedIdentityException) {
+                    final var identifier = ((ProtocolUntrustedIdentityException) exception).getSender();
                     final var recipientId = resolveRecipient(identifier);
                     queuedActions.add(new RetrieveProfileAction(recipientId));
                     if (!envelope.hasSource()) {
@@ -1935,7 +2011,7 @@ public class Manager implements Closeable {
         return sourceContact != null && sourceContact.isBlocked();
     }
 
-    private boolean isNotAGroupMember(
+    private boolean isNotAllowedToSendToGroup(
             SignalServiceEnvelope envelope, SignalServiceContent content
     ) {
         SignalServiceAddress source;
@@ -1947,23 +2023,32 @@ public class Manager implements Closeable {
             return false;
         }
 
-        if (content != null && content.getDataMessage().isPresent()) {
-            var message = content.getDataMessage().get();
-            if (message.getGroupContext().isPresent()) {
-                if (message.getGroupContext().get().getGroupV1().isPresent()) {
-                    var groupInfo = message.getGroupContext().get().getGroupV1().get();
-                    if (groupInfo.getType() == SignalServiceGroup.Type.QUIT) {
-                        return false;
-                    }
-                }
-                var groupId = GroupUtils.getGroupId(message.getGroupContext().get());
-                var group = getGroup(groupId);
-                if (group != null && !group.isMember(resolveRecipient(source))) {
-                    return true;
-                }
+        if (content == null || !content.getDataMessage().isPresent()) {
+            return false;
+        }
+
+        var message = content.getDataMessage().get();
+        if (!message.getGroupContext().isPresent()) {
+            return false;
+        }
+
+        if (message.getGroupContext().get().getGroupV1().isPresent()) {
+            var groupInfo = message.getGroupContext().get().getGroupV1().get();
+            if (groupInfo.getType() == SignalServiceGroup.Type.QUIT) {
+                return false;
             }
         }
-        return false;
+
+        var groupId = GroupUtils.getGroupId(message.getGroupContext().get());
+        var group = getGroup(groupId);
+        if (group == null) {
+            return false;
+        }
+
+        final var recipientId = resolveRecipient(source);
+        return !group.isMember(recipientId) || (
+                group.isAnnouncementGroup() && !group.isAdmin(recipientId)
+        );
     }
 
     private List<HandleAction> handleMessage(
@@ -2024,7 +2109,16 @@ public class Manager implements Closeable {
                         try (var attachmentAsStream = retrieveAttachmentAsStream(groupsMessage.asPointer(), tmpFile)) {
                             var s = new DeviceGroupsInputStream(attachmentAsStream);
                             DeviceGroup g;
-                            while ((g = s.read()) != null) {
+                            while (true) {
+                                try {
+                                    g = s.read();
+                                } catch (IOException e) {
+                                    logger.warn("Sync groups contained invalid group, ignoring: {}", e.getMessage());
+                                    continue;
+                                }
+                                if (g == null) {
+                                    break;
+                                }
                                 var syncGroup = account.getGroupStore().getOrCreateGroupV1(GroupId.v1(g.getId()));
                                 if (syncGroup != null) {
                                     if (g.getName().isPresent()) {
@@ -2095,7 +2189,17 @@ public class Manager implements Closeable {
                                 .asPointer(), tmpFile)) {
                             var s = new DeviceContactsInputStream(attachmentAsStream);
                             DeviceContact c;
-                            while ((c = s.read()) != null) {
+                            while (true) {
+                                try {
+                                    c = s.read();
+                                } catch (IOException e) {
+                                    logger.warn("Sync contacts contained invalid contact, ignoring: {}",
+                                            e.getMessage());
+                                    continue;
+                                }
+                                if (c == null) {
+                                    break;
+                                }
                                 if (c.getAddress().matches(account.getSelfAddress()) && c.getProfileKey().isPresent()) {
                                     account.setProfileKey(c.getProfileKey().get());
                                 }
@@ -2162,16 +2266,23 @@ public class Manager implements Closeable {
                             continue;
                         }
                         final var stickerPackId = StickerPackId.deserialize(m.getPackId().get());
+                        final var installed = !m.getType().isPresent()
+                                || m.getType().get() == StickerPackOperationMessage.Type.INSTALL;
+
                         var sticker = account.getStickerStore().getSticker(stickerPackId);
-                        if (sticker == null) {
-                            if (!m.getPackKey().isPresent()) {
-                                continue;
+                        if (m.getPackKey().isPresent()) {
+                            if (sticker == null) {
+                                sticker = new Sticker(stickerPackId, m.getPackKey().get());
+                            }
+                            if (installed) {
+                                enqueueJob(new RetrieveStickerPackJob(stickerPackId, m.getPackKey().get()));
                             }
-                            sticker = new Sticker(stickerPackId, m.getPackKey().get());
                         }
-                        sticker.setInstalled(!m.getType().isPresent()
-                                || m.getType().get() == StickerPackOperationMessage.Type.INSTALL);
-                        account.getStickerStore().updateSticker(sticker);
+
+                        if (sticker != null) {
+                            sticker.setInstalled(installed);
+                            account.getStickerStore().updateSticker(sticker);
+                        }
                     }
                 }
                 if (syncMessage.getFetchType().isPresent()) {
@@ -2229,6 +2340,9 @@ public class Manager implements Closeable {
             avatarStore.storeProfileAvatar(address,
                     outputStream -> retrieveProfileAvatar(avatarPath, profileKey, outputStream));
         } catch (Throwable e) {
+            if (e instanceof AssertionError && e.getCause() instanceof InterruptedException) {
+                Thread.currentThread().interrupt();
+            }
             logger.warn("Failed to download profile avatar, ignoring: {}", e.getMessage());
         }
     }
@@ -2264,12 +2378,11 @@ public class Manager implements Closeable {
     private void retrieveGroupV2Avatar(
             GroupSecretParams groupSecretParams, String cdnKey, OutputStream outputStream
     ) throws IOException {
-        var groupOperations = groupsV2Operations.forGroup(groupSecretParams);
+        var groupOperations = dependencies.getGroupsV2Operations().forGroup(groupSecretParams);
 
         var tmpFile = IOUtils.createTempFile();
-        try (InputStream input = messageReceiver.retrieveGroupsV2ProfileAvatar(cdnKey,
-                tmpFile,
-                ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE)) {
+        try (InputStream input = dependencies.getMessageReceiver()
+                .retrieveGroupsV2ProfileAvatar(cdnKey, tmpFile, ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE)) {
             var encryptedData = IOUtils.readFully(input);
 
             var decryptedData = groupOperations.decryptAvatar(encryptedData);
@@ -2289,10 +2402,11 @@ public class Manager implements Closeable {
             String avatarPath, ProfileKey profileKey, OutputStream outputStream
     ) throws IOException {
         var tmpFile = IOUtils.createTempFile();
-        try (var input = messageReceiver.retrieveProfileAvatar(avatarPath,
-                tmpFile,
-                profileKey,
-                ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE)) {
+        try (var input = dependencies.getMessageReceiver()
+                .retrieveProfileAvatar(avatarPath,
+                        tmpFile,
+                        profileKey,
+                        ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE)) {
             // Use larger buffer size to prevent AssertionError: Need: 12272 but only have: 8192 ...
             IOUtils.copyStream(input, outputStream, (int) ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE);
         } finally {
@@ -2340,10 +2454,11 @@ public class Manager implements Closeable {
     private InputStream retrieveAttachmentAsStream(
             SignalServiceAttachmentPointer pointer, File tmpFile
     ) throws IOException, InvalidMessageException, MissingConfigurationException {
-        return messageReceiver.retrieveAttachment(pointer, tmpFile, ServiceConfig.MAX_ATTACHMENT_SIZE);
+        return dependencies.getMessageReceiver()
+                .retrieveAttachment(pointer, tmpFile, ServiceConfig.MAX_ATTACHMENT_SIZE);
     }
 
-    void sendGroups() throws IOException, UntrustedIdentityException {
+    void sendGroups() throws IOException {
         var groupsFile = IOUtils.createTempFile();
 
         try {
@@ -2377,7 +2492,7 @@ public class Manager implements Closeable {
                             .withLength(groupsFile.length())
                             .build();
 
-                    sendSyncMessage(SignalServiceSyncMessage.forGroups(attachmentStream));
+                    sendHelper.sendSyncMessage(SignalServiceSyncMessage.forGroups(attachmentStream));
                 }
             }
         } finally {
@@ -2389,7 +2504,7 @@ public class Manager implements Closeable {
         }
     }
 
-    public void sendContacts() throws IOException, UntrustedIdentityException {
+    public void sendContacts() throws IOException {
         var contactsFile = IOUtils.createTempFile();
 
         try {
@@ -2445,7 +2560,8 @@ public class Manager implements Closeable {
                             .withLength(contactsFile.length())
                             .build();
 
-                    sendSyncMessage(SignalServiceSyncMessage.forContacts(new ContactsMessage(attachmentStream, true)));
+                    sendHelper.sendSyncMessage(SignalServiceSyncMessage.forContacts(new ContactsMessage(attachmentStream,
+                            true)));
                 }
             }
         } finally {
@@ -2457,7 +2573,7 @@ public class Manager implements Closeable {
         }
     }
 
-    void sendBlockedList() throws IOException, UntrustedIdentityException {
+    void sendBlockedList() throws IOException {
         var addresses = new ArrayList<SignalServiceAddress>();
         for (var record : account.getContactStore().getContacts()) {
             if (record.second().isBlocked()) {
@@ -2470,17 +2586,17 @@ public class Manager implements Closeable {
                 groupIds.add(record.getGroupId().serialize());
             }
         }
-        sendSyncMessage(SignalServiceSyncMessage.forBlocked(new BlockedListMessage(addresses, groupIds)));
+        sendHelper.sendSyncMessage(SignalServiceSyncMessage.forBlocked(new BlockedListMessage(addresses, groupIds)));
     }
 
     private void sendVerifiedMessage(
             SignalServiceAddress destination, IdentityKey identityKey, TrustLevel trustLevel
-    ) throws IOException, UntrustedIdentityException {
+    ) throws IOException {
         var verifiedMessage = new VerifiedMessage(destination,
                 identityKey,
                 trustLevel.toVerifiedState(),
                 System.currentTimeMillis());
-        sendSyncMessage(SignalServiceSyncMessage.forVerified(verifiedMessage));
+        sendHelper.sendSyncMessage(SignalServiceSyncMessage.forVerified(verifiedMessage));
     }
 
     public List<Pair<RecipientId, Contact>> getContacts() {
@@ -2506,10 +2622,14 @@ public class Manager implements Closeable {
     }
 
     public GroupInfo getGroup(GroupId groupId) {
+        return getGroup(groupId, false);
+    }
+
+    public GroupInfo getGroup(GroupId groupId, boolean forceUpdate) {
         final var group = account.getGroupStore().getGroup(groupId);
-        if (group instanceof GroupInfoV2 && ((GroupInfoV2) group).getGroup() == null) {
+        if (group instanceof GroupInfoV2 && (forceUpdate || ((GroupInfoV2) group).getGroup() == null)) {
             final var groupSecretParams = GroupSecretParams.deriveFromMasterKey(((GroupInfoV2) group).getMasterKey());
-            ((GroupInfoV2) group).setGroup(groupHelper.getDecryptedGroup(groupSecretParams), this::resolveRecipient);
+            ((GroupInfoV2) group).setGroup(groupV2Helper.getDecryptedGroup(groupSecretParams), this::resolveRecipient);
             account.getGroupStore().updateGroup(group);
         }
         return group;
@@ -2551,6 +2671,25 @@ public class Manager implements Closeable {
                 TrustLevel.TRUSTED_VERIFIED);
     }
 
+    /**
+     * Trust this the identity with this scannable safety number
+     *
+     * @param name         username of the identity
+     * @param safetyNumber Scannable safety number
+     */
+    public boolean trustIdentityVerifiedSafetyNumber(String name, byte[] safetyNumber) throws InvalidNumberException {
+        var recipientId = canonicalizeAndResolveRecipient(name);
+        var address = account.getRecipientStore().resolveServiceAddress(recipientId);
+        return trustIdentity(recipientId, identityKey -> {
+            final var fingerprint = computeSafetyNumberFingerprint(address, identityKey);
+            try {
+                return fingerprint != null && fingerprint.getScannableFingerprint().compareTo(safetyNumber);
+            } catch (FingerprintVersionMismatchException | FingerprintParsingException e) {
+                return false;
+            }
+        }, TrustLevel.TRUSTED_VERIFIED);
+    }
+
     /**
      * Trust all keys of this identity without verification
      *
@@ -2577,17 +2716,42 @@ public class Manager implements Closeable {
         try {
             var address = account.getRecipientStore().resolveServiceAddress(recipientId);
             sendVerifiedMessage(address, identity.getIdentityKey(), trustLevel);
-        } catch (IOException | UntrustedIdentityException e) {
+        } catch (IOException e) {
             logger.warn("Failed to send verification sync message: {}", e.getMessage());
         }
 
         return true;
     }
 
-    public String computeSafetyNumber(
-            SignalServiceAddress theirAddress, IdentityKey theirIdentityKey
+    private void handleIdentityFailure(
+            final RecipientId recipientId, final SendMessageResult.IdentityFailure identityFailure
+    ) {
+        final var identityKey = identityFailure.getIdentityKey();
+        if (identityKey != null) {
+            final var newIdentity = account.getIdentityKeyStore().saveIdentity(recipientId, identityKey, new Date());
+            if (newIdentity) {
+                account.getSessionStore().archiveSessions(recipientId);
+            }
+        } else {
+            // Retrieve profile to get the current identity key from the server
+            retrieveEncryptedProfile(recipientId);
+        }
+    }
+
+    public String computeSafetyNumber(SignalServiceAddress theirAddress, IdentityKey theirIdentityKey) {
+        final Fingerprint fingerprint = computeSafetyNumberFingerprint(theirAddress, theirIdentityKey);
+        return fingerprint == null ? null : fingerprint.getDisplayableFingerprint().getDisplayText();
+    }
+
+    public byte[] computeSafetyNumberForScanning(SignalServiceAddress theirAddress, IdentityKey theirIdentityKey) {
+        final Fingerprint fingerprint = computeSafetyNumberFingerprint(theirAddress, theirIdentityKey);
+        return fingerprint == null ? null : fingerprint.getScannableFingerprint().getSerialized();
+    }
+
+    private Fingerprint computeSafetyNumberFingerprint(
+            final SignalServiceAddress theirAddress, final IdentityKey theirIdentityKey
     ) {
-        return Utils.computeSafetyNumber(ServiceConfig.capabilities.isUuid(),
+        return Utils.computeSafetyNumber(capabilities.isUuid(),
                 account.getSelfAddress(),
                 getIdentityKeyPair().getPublicKey(),
                 theirAddress,
@@ -2614,14 +2778,16 @@ public class Manager implements Closeable {
         return account.getRecipientStore().resolveServiceAddress(recipientId);
     }
 
-    public RecipientId canonicalizeAndResolveRecipient(String identifier) throws InvalidNumberException {
-        var canonicalizedNumber = UuidUtil.isUuid(identifier)
-                ? identifier
-                : PhoneNumberFormatter.formatNumber(identifier, account.getUsername());
+    private RecipientId canonicalizeAndResolveRecipient(String identifier) throws InvalidNumberException {
+        var canonicalizedNumber = UuidUtil.isUuid(identifier) ? identifier : canonicalizePhoneNumber(identifier);
 
         return resolveRecipient(canonicalizedNumber);
     }
 
+    private String canonicalizePhoneNumber(final String number) throws InvalidNumberException {
+        return PhoneNumberFormatter.formatNumber(number, account.getUsername());
+    }
+
     private RecipientId resolveRecipient(final String identifier) {
         var address = Utils.getSignalServiceAddressFromIdentifier(identifier);
 
@@ -2636,6 +2802,14 @@ public class Manager implements Closeable {
         return account.getRecipientStore().resolveRecipientTrusted(address);
     }
 
+    private void enqueueJob(Job job) {
+        var context = new Context(account,
+                dependencies.getAccountManager(),
+                dependencies.getMessageReceiver(),
+                stickerPackStore);
+        job.run(context);
+    }
+
     @Override
     public void close() throws IOException {
         close(true);
@@ -2644,15 +2818,7 @@ public class Manager implements Closeable {
     void close(boolean closeAccount) throws IOException {
         executor.shutdown();
 
-        if (messagePipe != null) {
-            messagePipe.shutdown();
-            messagePipe = null;
-        }
-
-        if (unidentifiedMessagePipe != null) {
-            unidentifiedMessagePipe.shutdown();
-            unidentifiedMessagePipe = null;
-        }
+        dependencies.getSignalWebSocket().disconnect();
 
         if (closeAccount && account != null) {
             account.close();