Implement a sticker store

[signal-cli] / src / main / java / org / asamk / signal / manager / Manager.java

diff --git a/src/main/java/org/asamk/signal/manager/Manager.java b/src/main/java/org/asamk/signal/manager/Manager.java
index a4127b75c369d6ce0f0c1b0ba27097f9908001ac..56376f0e8bdab689346cfc0895cb329fd7cbb4a1 100644 (file)
--- a/src/main/java/org/asamk/signal/manager/Manager.java
+++ b/src/main/java/org/asamk/signal/manager/Manager.java
@@ -21,10 +21,12 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import org.asamk.signal.storage.SignalAccount;
 import org.asamk.signal.storage.contacts.ContactInfo;
 import org.asamk.signal.storage.groups.GroupInfo;
 import org.asamk.signal.storage.SignalAccount;
 import org.asamk.signal.storage.contacts.ContactInfo;
 import org.asamk.signal.storage.groups.GroupInfo;

-import org.asamk.signal.storage.groups.JsonGroupStore;
+import org.asamk.signal.storage.groups.GroupInfoV1;
+import org.asamk.signal.storage.groups.GroupInfoV2;

 import org.asamk.signal.storage.profiles.SignalProfile;
 import org.asamk.signal.storage.profiles.SignalProfileEntry;
 import org.asamk.signal.storage.protocol.JsonIdentityKeyStore;
 import org.asamk.signal.storage.profiles.SignalProfile;
 import org.asamk.signal.storage.profiles.SignalProfileEntry;
 import org.asamk.signal.storage.protocol.JsonIdentityKeyStore;

+import org.asamk.signal.storage.stickers.Sticker;

 import org.asamk.signal.util.IOUtils;
 import org.asamk.signal.util.Util;
 import org.signal.libsignal.metadata.InvalidMetadataMessageException;
 import org.asamk.signal.util.IOUtils;
 import org.asamk.signal.util.Util;
 import org.signal.libsignal.metadata.InvalidMetadataMessageException;


@@ -39,7 +41,13 @@ import org.signal.libsignal.metadata.ProtocolNoSessionException;
 import org.signal.libsignal.metadata.ProtocolUntrustedIdentityException;
 import org.signal.libsignal.metadata.SelfSendException;
 import org.signal.libsignal.metadata.certificate.InvalidCertificateException;
 import org.signal.libsignal.metadata.ProtocolUntrustedIdentityException;
 import org.signal.libsignal.metadata.SelfSendException;
 import org.signal.libsignal.metadata.certificate.InvalidCertificateException;

+import org.signal.storageservice.protos.groups.local.DecryptedGroup;
+import org.signal.storageservice.protos.groups.local.DecryptedMember;

 import org.signal.zkgroup.InvalidInputException;
 import org.signal.zkgroup.InvalidInputException;

+import org.signal.zkgroup.VerificationFailedException;
+import org.signal.zkgroup.auth.AuthCredentialResponse;
+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.whispersystems.libsignal.IdentityKey;
 import org.signal.zkgroup.profiles.ClientZkProfileOperations;
 import org.signal.zkgroup.profiles.ProfileKey;
 import org.whispersystems.libsignal.IdentityKey;


@@ -67,7 +75,10 @@ import org.whispersystems.signalservice.api.crypto.UnidentifiedAccess;
 import org.whispersystems.signalservice.api.crypto.UnidentifiedAccessPair;
 import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
 import org.whispersystems.signalservice.api.groupsv2.ClientZkOperations;
 import org.whispersystems.signalservice.api.crypto.UnidentifiedAccessPair;
 import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
 import org.whispersystems.signalservice.api.groupsv2.ClientZkOperations;

+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.groupsv2.GroupsV2Operations;

+import org.whispersystems.signalservice.api.groupsv2.InvalidGroupStateException;

 import org.whispersystems.signalservice.api.messages.SendMessageResult;
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachment;
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPointer;
 import org.whispersystems.signalservice.api.messages.SendMessageResult;
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachment;
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPointer;


@@ -77,6 +88,7 @@ import org.whispersystems.signalservice.api.messages.SignalServiceContent;
 import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage;
 import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope;
 import org.whispersystems.signalservice.api.messages.SignalServiceGroup;
 import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage;
 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.SignalServiceStickerManifestUpload;
 import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifestUpload.StickerInfo;
 import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage;
 import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifestUpload;
 import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifestUpload.StickerInfo;


@@ -92,14 +104,12 @@ import org.whispersystems.signalservice.api.messages.multidevice.DeviceInfo;
 import org.whispersystems.signalservice.api.messages.multidevice.RequestMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.SentTranscriptMessage;
 import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
 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.SignalServiceProfile;
 import org.whispersystems.signalservice.api.push.ContactTokenDetails;
 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
 import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage;
 import org.whispersystems.signalservice.api.profiles.SignalServiceProfile;
 import org.whispersystems.signalservice.api.push.ContactTokenDetails;
 import org.whispersystems.signalservice.api.push.SignalServiceAddress;

-import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions;

 import org.whispersystems.signalservice.api.push.exceptions.MissingConfigurationException;
 import org.whispersystems.signalservice.api.push.exceptions.MissingConfigurationException;

-import org.whispersystems.signalservice.api.push.exceptions.NetworkFailureException;
-import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;

 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 import org.whispersystems.signalservice.api.util.SleepTimer;
 import org.whispersystems.signalservice.api.util.StreamDetails;
 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 import org.whispersystems.signalservice.api.util.SleepTimer;
 import org.whispersystems.signalservice.api.util.StreamDetails;


@@ -133,8 +143,8 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;

+import java.util.HashMap;

 import java.util.HashSet;
 import java.util.HashSet;

-import java.util.LinkedList;

 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;


@@ -159,9 +169,10 @@ public class Manager implements Closeable {
     private final SignalAccount account;
     private final PathConfig pathConfig;
     private SignalServiceAccountManager accountManager;
     private final SignalAccount account;
     private final PathConfig pathConfig;
     private SignalServiceAccountManager accountManager;

+    private GroupsV2Api groupsV2Api;

     private SignalServiceMessagePipe messagePipe = null;
     private SignalServiceMessagePipe unidentifiedMessagePipe = null;
     private SignalServiceMessagePipe messagePipe = null;
     private SignalServiceMessagePipe unidentifiedMessagePipe = null;

-    private boolean discoverableByPhoneNumber = true;
+    private final boolean discoverableByPhoneNumber = true;

 
     public Manager(SignalAccount account, PathConfig pathConfig, SignalServiceConfiguration serviceConfiguration, String userAgent) {
         this.account = account;
 
     public Manager(SignalAccount account, PathConfig pathConfig, SignalServiceConfiguration serviceConfiguration, String userAgent) {
         this.account = account;


@@ -169,6 +180,7 @@ public class Manager implements Closeable {
         this.serviceConfiguration = serviceConfiguration;
         this.userAgent = userAgent;
         this.accountManager = createSignalServiceAccountManager();
         this.serviceConfiguration = serviceConfiguration;
         this.userAgent = userAgent;
         this.accountManager = createSignalServiceAccountManager();

+        this.groupsV2Api = accountManager.getGroupsV2Api();

 
         this.account.setResolver(this::resolveSignalServiceAddress);
     }
 
         this.account.setResolver(this::resolveSignalServiceAddress);
     }


@@ -182,12 +194,10 @@ public class Manager implements Closeable {
     }
 
     private SignalServiceAccountManager createSignalServiceAccountManager() {
     }
 
     private SignalServiceAccountManager createSignalServiceAccountManager() {

-        GroupsV2Operations groupsV2Operations;
-        try {
-            groupsV2Operations = new GroupsV2Operations(ClientZkOperations.create(serviceConfiguration));
-        } catch (Throwable ignored) {
-            groupsV2Operations = null;
-        }
+        GroupsV2Operations groupsV2Operations = capabilities.isGv2()
+                ? new GroupsV2Operations(ClientZkOperations.create(serviceConfiguration))
+                : null;
+

         return new SignalServiceAccountManager(serviceConfiguration,
                 new DynamicCredentialsProvider(account.getUuid(), account.getUsername(), account.getPassword(), null, account.getDeviceId()),
                 userAgent,
         return new SignalServiceAccountManager(serviceConfiguration,
                 new DynamicCredentialsProvider(account.getUuid(), account.getUsername(), account.getPassword(), null, account.getDeviceId()),
                 userAgent,


@@ -240,29 +250,12 @@ public class Manager implements Closeable {
         Manager m = new Manager(account, pathConfig, serviceConfiguration, userAgent);
 
         m.migrateLegacyConfigs();
         Manager m = new Manager(account, pathConfig, serviceConfiguration, userAgent);
 
         m.migrateLegacyConfigs();

+        m.updateAccountAttributes();

 
         return m;
     }
 
     private void migrateLegacyConfigs() {
 
         return m;
     }
 
     private void migrateLegacyConfigs() {

-        // Copy group avatars that were previously stored in the attachments folder
-        // to the new avatar folder
-        if (JsonGroupStore.groupsWithLegacyAvatarId.size() > 0) {
-            for (GroupInfo g : JsonGroupStore.groupsWithLegacyAvatarId) {
-                File avatarFile = getGroupAvatarFile(g.groupId);
-                File attachmentFile = getAttachmentFile(new SignalServiceAttachmentRemoteId(g.getAvatarId()));
-                if (!avatarFile.exists() && attachmentFile.exists()) {
-                    try {
-                        IOUtils.createPrivateDirectories(pathConfig.getAvatarsPath());
-                        Files.copy(attachmentFile.toPath(), avatarFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
-                    } catch (Exception e) {
-                        // Ignore
-                    }
-                }
-            }
-            JsonGroupStore.groupsWithLegacyAvatarId.clear();
-            account.save();
-        }

         if (account.getProfileKey() == null) {
             // Old config file, creating new profile key
             account.setProfileKey(KeyUtils.createProfileKey());
         if (account.getProfileKey() == null) {
             // Old config file, creating new profile key
             account.setProfileKey(KeyUtils.createProfileKey());


@@ -302,17 +295,18 @@ public class Manager implements Closeable {
         return account.isRegistered();
     }
 
         return account.isRegistered();
     }
 

-    public void register(boolean voiceVerification) throws IOException {
+    public void register(boolean voiceVerification, String captcha) throws IOException {

         account.setPassword(KeyUtils.createPassword());
 
         // Resetting UUID, because registering doesn't work otherwise
         account.setUuid(null);
         accountManager = createSignalServiceAccountManager();
         account.setPassword(KeyUtils.createPassword());
 
         // Resetting UUID, because registering doesn't work otherwise
         account.setUuid(null);
         accountManager = createSignalServiceAccountManager();

+        this.groupsV2Api = accountManager.getGroupsV2Api();

 
         if (voiceVerification) {
 
         if (voiceVerification) {

-            accountManager.requestVoiceVerificationCode(Locale.getDefault(), Optional.absent(), Optional.absent());
+            accountManager.requestVoiceVerificationCode(Locale.getDefault(), Optional.fromNullable(captcha), Optional.absent());

         } else {
         } else {

-            accountManager.requestSmsVerificationCode(false, Optional.absent(), Optional.absent());
+            accountManager.requestSmsVerificationCode(false, Optional.fromNullable(captcha), Optional.absent());

         }
 
         account.setRegistered(false);
         }
 
         account.setRegistered(false);


@@ -439,14 +433,16 @@ public class Manager implements Closeable {
     }
 
     private SignalServiceMessageReceiver getMessageReceiver() {
     }
 
     private SignalServiceMessageReceiver getMessageReceiver() {

-        // TODO implement ZkGroup support
-        final ClientZkProfileOperations clientZkProfileOperations = null;
+        final ClientZkProfileOperations clientZkProfileOperations = capabilities.isGv2()
+                ? ClientZkOperations.create(serviceConfiguration).getProfileOperations()
+                : null;

         return new SignalServiceMessageReceiver(serviceConfiguration, account.getUuid(), account.getUsername(), account.getPassword(), account.getDeviceId(), account.getSignalingKey(), userAgent, null, timer, clientZkProfileOperations);
     }
 
     private SignalServiceMessageSender getMessageSender() {
         return new SignalServiceMessageReceiver(serviceConfiguration, account.getUuid(), account.getUsername(), account.getPassword(), account.getDeviceId(), account.getSignalingKey(), userAgent, null, timer, clientZkProfileOperations);
     }
 
     private SignalServiceMessageSender getMessageSender() {

-        // TODO implement ZkGroup support
-        final ClientZkProfileOperations clientZkProfileOperations = null;
+        final ClientZkProfileOperations clientZkProfileOperations = capabilities.isGv2()
+                ? ClientZkOperations.create(serviceConfiguration).getProfileOperations()
+                : null;

         final ExecutorService executor = null;
         return new SignalServiceMessageSender(serviceConfiguration, 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);
         final ExecutorService executor = null;
         return new SignalServiceMessageSender(serviceConfiguration, 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);


@@ -531,7 +527,7 @@ public class Manager implements Closeable {
             throw new GroupNotFoundException(groupId);
         }
         if (!g.isMember(account.getSelfAddress())) {
             throw new GroupNotFoundException(groupId);
         }
         if (!g.isMember(account.getSelfAddress())) {

-            throw new NotAGroupMemberException(groupId, g.name);
+            throw new NotAGroupMemberException(groupId, g.getTitle());

         }
         return g;
     }
         }
         return g;
     }


@@ -540,44 +536,52 @@ public class Manager implements Closeable {
         return account.getGroupStore().getGroups();
     }
 
         return account.getGroupStore().getGroups();
     }
 

-    public long sendGroupMessage(String messageText, List<String> attachments,
-                                 byte[] groupId)
-            throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
+    public Pair<Long, List<SendMessageResult>> sendGroupMessage(
+            String messageText,
+            List<String> attachments,
+            byte[] groupId
+    )
+            throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {

         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
         if (attachments != null) {
             messageBuilder.withAttachments(Utils.getSignalServiceAttachments(attachments));
         }
         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
         if (attachments != null) {
             messageBuilder.withAttachments(Utils.getSignalServiceAttachments(attachments));
         }

-        if (groupId != null) {
-            SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER)
-                    .withId(groupId)
-                    .build();
-            messageBuilder.asGroupMessage(group);
-        }

 
         final GroupInfo g = getGroupForSending(groupId);
 
 
         final GroupInfo g = getGroupForSending(groupId);
 

-        messageBuilder.withExpiration(g.messageExpirationTime);
+        setGroupContext(messageBuilder, g);
+        messageBuilder.withExpiration(g.getMessageExpirationTime());

 
 

-        return sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));

     }
 
     }
 

-    public void sendGroupMessageReaction(String emoji, boolean remove, String targetAuthor,
-                                         long targetSentTimestamp, byte[] groupId)
-            throws IOException, EncapsulatedExceptions, InvalidNumberException, NotAGroupMemberException, GroupNotFoundException {
-        SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, canonicalizeAndResolveSignalServiceAddress(targetAuthor), targetSentTimestamp);
-        final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
-                .withReaction(reaction);
-        if (groupId != null) {
+    private void setGroupContext(final SignalServiceDataMessage.Builder messageBuilder, final GroupInfo groupInfo) {
+        if (groupInfo instanceof GroupInfoV1) {

             SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER)
             SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER)

-                    .withId(groupId)
+                    .withId(groupInfo.groupId)
+                    .build();
+            messageBuilder.asGroupMessage(group);
+        } else {
+            final GroupInfoV2 groupInfoV2 = (GroupInfoV2) groupInfo;
+            SignalServiceGroupV2 group = SignalServiceGroupV2.newBuilder(groupInfoV2.getMasterKey())
+                    .withRevision(groupInfoV2.getGroup() == null ? 0 : groupInfoV2.getGroup().getRevision())

                     .build();
             messageBuilder.asGroupMessage(group);
         }
                     .build();
             messageBuilder.asGroupMessage(group);
         }

+    }
+
+    public Pair<Long, List<SendMessageResult>> sendGroupMessageReaction(String emoji, boolean remove, String targetAuthor,
+                                                                        long targetSentTimestamp, byte[] groupId)
+            throws IOException, InvalidNumberException, NotAGroupMemberException, GroupNotFoundException {
+        SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, canonicalizeAndResolveSignalServiceAddress(targetAuthor), targetSentTimestamp);
+        final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
+                .withReaction(reaction);

         final GroupInfo g = getGroupForSending(groupId);
         final GroupInfo g = getGroupForSending(groupId);

-        sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        setGroupContext(messageBuilder, g);
+        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));

     }
 
     }
 

-    public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions, NotAGroupMemberException {
+    public Pair<Long, List<SendMessageResult>> sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, NotAGroupMemberException {

         SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT)
                 .withId(groupId)
                 .build();
         SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT)
                 .withId(groupId)
                 .build();


@@ -586,20 +590,29 @@ public class Manager implements Closeable {
                 .asGroupMessage(group);
 
         final GroupInfo g = getGroupForSending(groupId);
                 .asGroupMessage(group);
 
         final GroupInfo g = getGroupForSending(groupId);

-        g.removeMember(account.getSelfAddress());
-        account.getGroupStore().updateGroup(g);
+        if (g instanceof GroupInfoV1) {
+            GroupInfoV1 groupInfoV1 = (GroupInfoV1) g;
+            groupInfoV1.removeMember(account.getSelfAddress());
+            account.getGroupStore().updateGroup(groupInfoV1);
+        } else {
+            throw new RuntimeException("TODO Not implemented!");
+        }

 
 

-        sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));

     }
 
     }
 

-    private byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection<SignalServiceAddress> members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
-        GroupInfo g;
+    private Pair<byte[], List<SendMessageResult>> sendUpdateGroupMessage(byte[] groupId, String name, Collection<SignalServiceAddress> members, String avatarFile) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
+        GroupInfoV1 g;

         if (groupId == null) {
             // Create new group
         if (groupId == null) {
             // Create new group

-            g = new GroupInfo(KeyUtils.createGroupId());
+            g = new GroupInfoV1(KeyUtils.createGroupId());

             g.addMembers(Collections.singleton(account.getSelfAddress()));
         } else {
             g.addMembers(Collections.singleton(account.getSelfAddress()));
         } else {

-            g = getGroupForSending(groupId);
+            GroupInfo group = getGroupForSending(groupId);
+            if (!(group instanceof GroupInfoV1)) {
+                throw new RuntimeException("TODO Not implemented!");
+            }
+            g = (GroupInfoV1) group;

         }
 
         if (name != null) {
         }
 
         if (name != null) {


@@ -637,27 +650,29 @@ public class Manager implements Closeable {
 
         SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g);
 
 
         SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g);
 

-        sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
-        return g.groupId;
+        final Pair<Long, List<SendMessageResult>> result = sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return new Pair<>(g.groupId, result.second());

     }
 
     }
 

-    void sendUpdateGroupMessage(byte[] groupId, SignalServiceAddress recipient) throws IOException, EncapsulatedExceptions, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException {
-        if (groupId == null) {
-            return;
+    Pair<Long, List<SendMessageResult>> sendUpdateGroupMessage(byte[] groupId, SignalServiceAddress recipient) throws IOException, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException {
+        GroupInfoV1 g;
+        GroupInfo group = getGroupForSending(groupId);
+        if (!(group instanceof GroupInfoV1)) {
+            throw new RuntimeException("TODO Not implemented!");

         }
         }

-        GroupInfo g = getGroupForSending(groupId);
+        g = (GroupInfoV1) group;

 
         if (!g.isMember(recipient)) {
 
         if (!g.isMember(recipient)) {

-            return;
+            throw new NotAGroupMemberException(groupId, g.name);

         }
 
         SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g);
 
         // Send group message only to the recipient who requested it
         }
 
         SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g);
 
         // Send group message only to the recipient who requested it

-        sendMessageLegacy(messageBuilder, Collections.singleton(recipient));
+        return sendMessage(messageBuilder, Collections.singleton(recipient));

     }
 
     }
 

-    private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfo g) throws AttachmentInvalidException {
+    private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfoV1 g) throws AttachmentInvalidException {

         SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.UPDATE)
                 .withId(g.groupId)
                 .withName(g.name)
         SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.UPDATE)
                 .withId(g.groupId)
                 .withName(g.name)


@@ -677,11 +692,7 @@ public class Manager implements Closeable {
                 .withExpiration(g.messageExpirationTime);
     }
 
                 .withExpiration(g.messageExpirationTime);
     }
 

-    void sendGroupInfoRequest(byte[] groupId, SignalServiceAddress recipient) throws IOException, EncapsulatedExceptions {
-        if (groupId == null) {
-            return;
-        }
-
+    Pair<Long, List<SendMessageResult>> sendGroupInfoRequest(byte[] groupId, SignalServiceAddress recipient) throws IOException {

         SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.REQUEST_INFO)
                 .withId(groupId);
 
         SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.REQUEST_INFO)
                 .withId(groupId);
 


@@ -689,7 +700,7 @@ public class Manager implements Closeable {
                 .asGroupMessage(group.build());
 
         // Send group info request message to the recipient who sent us a message with this groupId
                 .asGroupMessage(group.build());
 
         // Send group info request message to the recipient who sent us a message with this groupId

-        sendMessageLegacy(messageBuilder, Collections.singleton(recipient));
+        return sendMessage(messageBuilder, Collections.singleton(recipient));

     }
 
     void sendReceipt(SignalServiceAddress remoteAddress, long messageId) throws IOException, UntrustedIdentityException {
     }
 
     void sendReceipt(SignalServiceAddress remoteAddress, long messageId) throws IOException, UntrustedIdentityException {


@@ -700,9 +711,9 @@ public class Manager implements Closeable {
         getMessageSender().sendReceipt(remoteAddress, getAccessFor(remoteAddress), receiptMessage);
     }
 
         getMessageSender().sendReceipt(remoteAddress, getAccessFor(remoteAddress), receiptMessage);
     }
 

-    public long sendMessage(String messageText, List<String> attachments,
-                            List<String> recipients)
-            throws IOException, EncapsulatedExceptions, AttachmentInvalidException, InvalidNumberException {
+    public Pair<Long, List<SendMessageResult>> sendMessage(String messageText, List<String> attachments,
+                                                           List<String> recipients)
+            throws IOException, AttachmentInvalidException, InvalidNumberException {

         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
         if (attachments != null) {
             List<SignalServiceAttachment> attachmentStreams = Utils.getSignalServiceAttachments(attachments);
         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
         if (attachments != null) {
             List<SignalServiceAttachment> attachmentStreams = Utils.getSignalServiceAttachments(attachments);


@@ -720,25 +731,25 @@ public class Manager implements Closeable {
 
             messageBuilder.withAttachments(attachmentPointers);
         }
 
             messageBuilder.withAttachments(attachmentPointers);
         }

-        return sendMessageLegacy(messageBuilder, getSignalServiceAddresses(recipients));
+        return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));

     }
 
     }
 

-    public void sendMessageReaction(String emoji, boolean remove, String targetAuthor,
-                                    long targetSentTimestamp, List<String> recipients)
-            throws IOException, EncapsulatedExceptions, InvalidNumberException {
+    public Pair<Long, List<SendMessageResult>> sendMessageReaction(String emoji, boolean remove, String targetAuthor,
+                                                                   long targetSentTimestamp, List<String> recipients)
+            throws IOException, InvalidNumberException {

         SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, canonicalizeAndResolveSignalServiceAddress(targetAuthor), targetSentTimestamp);
         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
                 .withReaction(reaction);
         SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, canonicalizeAndResolveSignalServiceAddress(targetAuthor), targetSentTimestamp);
         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
                 .withReaction(reaction);

-        sendMessageLegacy(messageBuilder, getSignalServiceAddresses(recipients));
+        return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));

     }
 
     }
 

-    public void sendEndSessionMessage(List<String> recipients) throws IOException, EncapsulatedExceptions, InvalidNumberException {
+    public Pair<Long, List<SendMessageResult>> sendEndSessionMessage(List<String> recipients) throws IOException, InvalidNumberException {

         SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
                 .asEndSessionMessage();
 
         final Collection<SignalServiceAddress> signalServiceAddresses = getSignalServiceAddresses(recipients);
         try {
         SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
                 .asEndSessionMessage();
 
         final Collection<SignalServiceAddress> signalServiceAddresses = getSignalServiceAddresses(recipients);
         try {

-            sendMessageLegacy(messageBuilder, signalServiceAddresses);
+            return sendMessage(messageBuilder, signalServiceAddresses);

         } catch (Exception e) {
             for (SignalServiceAddress address : signalServiceAddresses) {
                 handleEndSession(address);
         } catch (Exception e) {
             for (SignalServiceAddress address : signalServiceAddresses) {
                 handleEndSession(address);


@@ -788,12 +799,12 @@ public class Manager implements Closeable {
             throw new GroupNotFoundException(groupId);
         }
 
             throw new GroupNotFoundException(groupId);
         }
 

-        group.blocked = blocked;
+        group.setBlocked(blocked);

         account.getGroupStore().updateGroup(group);
         account.save();
     }
 
         account.getGroupStore().updateGroup(group);
         account.save();
     }
 

-    public byte[] updateGroup(byte[] groupId, String name, List<String> members, String avatar) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException {
+    public Pair<byte[], List<SendMessageResult>> updateGroup(byte[] groupId, String name, List<String> members, String avatar) throws IOException, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException {

         if (groupId.length == 0) {
             groupId = null;
         }
         if (groupId.length == 0) {
             groupId = null;
         }


@@ -839,8 +850,13 @@ public class Manager implements Closeable {
      */
     public void setExpirationTimer(byte[] groupId, int messageExpirationTimer) {
         GroupInfo g = account.getGroupStore().getGroup(groupId);
      */
     public void setExpirationTimer(byte[] groupId, int messageExpirationTimer) {
         GroupInfo g = account.getGroupStore().getGroup(groupId);

-        g.messageExpirationTime = messageExpirationTimer;
-        account.getGroupStore().updateGroup(g);
+        if (g instanceof GroupInfoV1) {
+            GroupInfoV1 groupInfoV1 = (GroupInfoV1) g;
+            groupInfoV1.messageExpirationTime = messageExpirationTimer;
+            account.getGroupStore().updateGroup(groupInfoV1);
+        } else {
+            throw new RuntimeException("TODO Not implemented!");
+        }

     }
 
     /**
     }
 
     /**


@@ -857,6 +873,10 @@ public class Manager implements Closeable {
         byte[] packKey = KeyUtils.createStickerUploadKey();
         String packId = messageSender.uploadStickerManifest(manifest, packKey);
 
         byte[] packKey = KeyUtils.createStickerUploadKey();
         String packId = messageSender.uploadStickerManifest(manifest, packKey);
 

+        Sticker sticker = new Sticker(Hex.fromStringCondensed(packId), packKey);
+        account.getStickerStore().updateSticker(sticker);
+        account.save();
+

         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();
         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();


@@ -1098,34 +1118,6 @@ public class Manager implements Closeable {
         }
     }
 
         }
     }
 

-    /**
-     * This method throws an EncapsulatedExceptions exception instead of returning a list of SendMessageResult.
-     */
-    private long sendMessageLegacy(SignalServiceDataMessage.Builder messageBuilder, Collection<SignalServiceAddress> recipients)
-            throws EncapsulatedExceptions, IOException {
-        final long timestamp = System.currentTimeMillis();
-        messageBuilder.withTimestamp(timestamp);
-        List<SendMessageResult> results = sendMessage(messageBuilder, recipients);
-
-        List<UntrustedIdentityException> untrustedIdentities = new LinkedList<>();
-        List<UnregisteredUserException> unregisteredUsers = new LinkedList<>();
-        List<NetworkFailureException> networkExceptions = new LinkedList<>();
-
-        for (SendMessageResult result : results) {
-            if (result.isUnregisteredFailure()) {
-                unregisteredUsers.add(new UnregisteredUserException(result.getAddress().getLegacyIdentifier(), null));
-            } else if (result.isNetworkFailure()) {
-                networkExceptions.add(new NetworkFailureException(result.getAddress().getLegacyIdentifier(), null));
-            } else if (result.getIdentityFailure() != null) {
-                untrustedIdentities.add(new UntrustedIdentityException("Untrusted", result.getAddress().getLegacyIdentifier(), result.getIdentityFailure().getIdentityKey()));
-            }
-        }
-        if (!untrustedIdentities.isEmpty() || !unregisteredUsers.isEmpty() || !networkExceptions.isEmpty()) {
-            throw new EncapsulatedExceptions(untrustedIdentities, unregisteredUsers, networkExceptions);
-        }
-        return timestamp;
-    }
-

     private Collection<SignalServiceAddress> getSignalServiceAddresses(Collection<String> numbers) throws InvalidNumberException {
         final Set<SignalServiceAddress> signalServiceAddresses = new HashSet<>(numbers.size());
 
     private Collection<SignalServiceAddress> getSignalServiceAddresses(Collection<String> numbers) throws InvalidNumberException {
         final Set<SignalServiceAddress> signalServiceAddresses = new HashSet<>(numbers.size());
 


@@ -1135,8 +1127,11 @@ public class Manager implements Closeable {
         return signalServiceAddresses;
     }
 
         return signalServiceAddresses;
     }
 

-    private List<SendMessageResult> sendMessage(SignalServiceDataMessage.Builder messageBuilder, Collection<SignalServiceAddress> recipients)
+    private Pair<Long, List<SendMessageResult>> sendMessage(SignalServiceDataMessage.Builder messageBuilder, Collection<SignalServiceAddress> recipients)

             throws IOException {
             throws IOException {

+        recipients = recipients.stream().map(this::resolveSignalServiceAddress).collect(Collectors.toSet());
+        final long timestamp = System.currentTimeMillis();
+        messageBuilder.withTimestamp(timestamp);

         if (messagePipe == null) {
             messagePipe = getMessageReceiver().createMessagePipe();
         }
         if (messagePipe == null) {
             messagePipe = getMessageReceiver().createMessagePipe();
         }


@@ -1156,10 +1151,10 @@ public class Manager implements Closeable {
                             account.getSignalProtocolStore().saveIdentity(r.getAddress(), r.getIdentityFailure().getIdentityKey(), TrustLevel.UNTRUSTED);
                         }
                     }
                             account.getSignalProtocolStore().saveIdentity(r.getAddress(), r.getIdentityFailure().getIdentityKey(), TrustLevel.UNTRUSTED);
                         }
                     }

-                    return result;
+                    return new Pair<>(timestamp, result);

                 } catch (UntrustedIdentityException e) {
                     account.getSignalProtocolStore().saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), e.getIdentityKey(), TrustLevel.UNTRUSTED);
                 } catch (UntrustedIdentityException e) {
                     account.getSignalProtocolStore().saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), e.getIdentityKey(), TrustLevel.UNTRUSTED);

-                    return Collections.emptyList();
+                    return new Pair<>(timestamp, Collections.emptyList());

                 }
             } else {
                 // Send to all individually, so sync messages are sent correctly
                 }
             } else {
                 // Send to all individually, so sync messages are sent correctly


@@ -1180,7 +1175,7 @@ public class Manager implements Closeable {
                         results.add(sendMessage(address, message));
                     }
                 }
                         results.add(sendMessage(address, message));
                     }
                 }

-                return results;
+                return new Pair<>(timestamp, results);

             }
         } finally {
             if (message != null && message.isEndSession()) {
             }
         } finally {
             if (message != null && message.isEndSession()) {


@@ -1245,57 +1240,114 @@ public class Manager implements Closeable {
         account.getSignalProtocolStore().deleteAllSessions(source);
     }
 
         account.getSignalProtocolStore().deleteAllSessions(source);
     }
 

+    private static int currentTimeDays() {
+        return (int) TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
+    }
+
+    private GroupsV2AuthorizationString getGroupAuthForToday(final GroupSecretParams groupSecretParams) throws IOException, VerificationFailedException {
+        final int today = currentTimeDays();
+        // Returns credentials for the next 7 days
+        final HashMap<Integer, AuthCredentialResponse> credentials = groupsV2Api.getCredentials(today);
+        // TODO cache credentials until they expire
+        AuthCredentialResponse authCredentialResponse = credentials.get(today);
+        return groupsV2Api.getGroupsV2AuthorizationString(account.getUuid(), today, groupSecretParams, authCredentialResponse);
+    }
+

     private List<HandleAction> handleSignalServiceDataMessage(SignalServiceDataMessage message, boolean isSync, SignalServiceAddress source, SignalServiceAddress destination, boolean ignoreAttachments) {
         List<HandleAction> actions = new ArrayList<>();
     private List<HandleAction> handleSignalServiceDataMessage(SignalServiceDataMessage message, boolean isSync, SignalServiceAddress source, SignalServiceAddress destination, boolean ignoreAttachments) {
         List<HandleAction> actions = new ArrayList<>();

-        if (message.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) {
-            SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get();
-            GroupInfo group = account.getGroupStore().getGroup(groupInfo.getGroupId());
-            switch (groupInfo.getType()) {
-                case UPDATE:
-                    if (group == null) {
-                        group = new GroupInfo(groupInfo.getGroupId());
-                    }
+        if (message.getGroupContext().isPresent()) {
+            if (message.getGroupContext().get().getGroupV1().isPresent()) {
+                SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get();
+                GroupInfo group = account.getGroupStore().getGroup(groupInfo.getGroupId());
+                if (group == null || group instanceof GroupInfoV1) {
+                    GroupInfoV1 groupV1 = (GroupInfoV1) group;
+                    switch (groupInfo.getType()) {
+                        case UPDATE: {
+                            if (groupV1 == null) {
+                                groupV1 = new GroupInfoV1(groupInfo.getGroupId());
+                            }

 
 

-                    if (groupInfo.getAvatar().isPresent()) {
-                        SignalServiceAttachment avatar = groupInfo.getAvatar().get();
-                        if (avatar.isPointer()) {
-                            try {
-                                retrieveGroupAvatarAttachment(avatar.asPointer(), group.groupId);
-                            } catch (IOException | InvalidMessageException | MissingConfigurationException e) {
-                                System.err.println("Failed to retrieve group avatar (" + avatar.asPointer().getRemoteId() + "): " + e.getMessage());
+                            if (groupInfo.getAvatar().isPresent()) {
+                                SignalServiceAttachment avatar = groupInfo.getAvatar().get();
+                                if (avatar.isPointer()) {
+                                    try {
+                                        retrieveGroupAvatarAttachment(avatar.asPointer(), groupV1.groupId);
+                                    } catch (IOException | InvalidMessageException | MissingConfigurationException e) {
+                                        System.err.println("Failed to retrieve group avatar (" + avatar.asPointer().getRemoteId() + "): " + e.getMessage());
+                                    }
+                                }

                             }
                             }

-                        }
-                    }

 
 

-                    if (groupInfo.getName().isPresent()) {
-                        group.name = groupInfo.getName().get();
-                    }
+                            if (groupInfo.getName().isPresent()) {
+                                groupV1.name = groupInfo.getName().get();
+                            }

 
 

-                    if (groupInfo.getMembers().isPresent()) {
-                        group.addMembers(groupInfo.getMembers().get()
-                                .stream()
-                                .map(this::resolveSignalServiceAddress)
-                                .collect(Collectors.toSet()));
-                    }
+                            if (groupInfo.getMembers().isPresent()) {
+                                groupV1.addMembers(groupInfo.getMembers().get()
+                                        .stream()
+                                        .map(this::resolveSignalServiceAddress)
+                                        .collect(Collectors.toSet()));
+                            }

 
 

-                    account.getGroupStore().updateGroup(group);
-                    break;
-                case DELIVER:
-                    if (group == null && !isSync) {
-                        actions.add(new SendGroupInfoRequestAction(source, groupInfo.getGroupId()));
-                    }
-                    break;
-                case QUIT:
-                    if (group != null) {
-                        group.removeMember(source);
-                        account.getGroupStore().updateGroup(group);
+                            account.getGroupStore().updateGroup(groupV1);
+                            break;
+                        }
+                        case DELIVER:
+                            if (groupV1 == null && !isSync) {
+                                actions.add(new SendGroupInfoRequestAction(source, groupInfo.getGroupId()));
+                            }
+                            break;
+                        case QUIT: {
+                            if (groupV1 != null) {
+                                groupV1.removeMember(source);
+                                account.getGroupStore().updateGroup(groupV1);
+                            }
+                            break;
+                        }
+                        case REQUEST_INFO:
+                            if (groupV1 != null && !isSync) {
+                                actions.add(new SendGroupUpdateAction(source, groupV1.groupId));
+                            }
+                            break;

                     }
                     }

-                    break;
-                case REQUEST_INFO:
-                    if (group != null && !isSync) {
-                        actions.add(new SendGroupUpdateAction(source, group.groupId));
+                } else {
+                    System.err.println("Received a group v1 message for a v2 group: " + group.getTitle());
+                }
+            }
+            if (message.getGroupContext().get().getGroupV2().isPresent()) {
+                final SignalServiceGroupV2 groupContext = message.getGroupContext().get().getGroupV2().get();
+                final GroupMasterKey groupMasterKey = groupContext.getMasterKey();
+
+                final GroupSecretParams groupSecretParams = GroupSecretParams.deriveFromMasterKey(groupMasterKey);
+
+                byte[] groupId = groupSecretParams.getPublicParams().getGroupIdentifier().serialize();
+                GroupInfo groupInfo = account.getGroupStore().getGroup(groupId);
+                if (groupInfo instanceof GroupInfoV1) {
+                    // TODO upgrade group
+                } else if (groupInfo == null || groupInfo instanceof GroupInfoV2) {
+                    GroupInfoV2 groupInfoV2 = groupInfo == null
+                            ? new GroupInfoV2(groupId, groupMasterKey)
+                            : (GroupInfoV2) groupInfo;
+
+                    if (groupInfoV2.getGroup() == null || groupInfoV2.getGroup().getRevision() < groupContext.getRevision()) {
+                        // TODO check if revision is only 1 behind and a signedGroupChange is available
+                        try {
+                            final GroupsV2AuthorizationString groupsV2AuthorizationString = getGroupAuthForToday(groupSecretParams);
+                            final DecryptedGroup group = groupsV2Api.getGroup(groupSecretParams, groupsV2AuthorizationString);
+                            groupInfoV2.setGroup(group);
+                            for (DecryptedMember member : group.getMembersList()) {
+                                final SignalServiceAddress address = resolveSignalServiceAddress(new SignalServiceAddress(UuidUtil.parseOrThrow(member.getUuid().toByteArray()), null));
+                                try {
+                                    account.getProfileStore().storeProfileKey(address, new ProfileKey(member.getProfileKey().toByteArray()));
+                                } catch (InvalidInputException ignored) {
+                                }
+                            }
+                        } catch (IOException | VerificationFailedException | InvalidGroupStateException e) {
+                            System.err.println("Failed to retrieve Group V2 info, ignoring ...");
+                        }
+                        account.getGroupStore().updateGroup(groupInfoV2);

                     }
                     }

-                    break;
+                }

             }
         }
         final SignalServiceAddress conversationPartnerAddress = isSync ? destination : source;
             }
         }
         final SignalServiceAddress conversationPartnerAddress = isSync ? destination : source;


@@ -1303,15 +1355,18 @@ public class Manager implements Closeable {
             handleEndSession(conversationPartnerAddress);
         }
         if (message.isExpirationUpdate() || message.getBody().isPresent()) {
             handleEndSession(conversationPartnerAddress);
         }
         if (message.isExpirationUpdate() || message.getBody().isPresent()) {

-            if (message.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) {
-                SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get();
-                GroupInfo group = account.getGroupStore().getGroup(groupInfo.getGroupId());
-                if (group == null) {
-                    group = new GroupInfo(groupInfo.getGroupId());
-                }
-                if (group.messageExpirationTime != message.getExpiresInSeconds()) {
-                    group.messageExpirationTime = message.getExpiresInSeconds();
-                    account.getGroupStore().updateGroup(group);
+            if (message.getGroupContext().isPresent()) {
+                if (message.getGroupContext().get().getGroupV1().isPresent()) {
+                    SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get();
+                    GroupInfoV1 group = account.getGroupStore().getOrCreateGroupV1(groupInfo.getGroupId());
+                    if (group != null) {
+                        if (group.messageExpirationTime != message.getExpiresInSeconds()) {
+                            group.messageExpirationTime = message.getExpiresInSeconds();
+                            account.getGroupStore().updateGroup(group);
+                        }
+                    }
+                } else if (message.getGroupContext().get().getGroupV2().isPresent()) {
+                    // disappearing message timer already stored in the DecryptedGroup

                 }
             } else {
                 ContactInfo contact = account.getContactStore().getContact(conversationPartnerAddress);
                 }
             } else {
                 ContactInfo contact = account.getContactStore().getContact(conversationPartnerAddress);


@@ -1360,6 +1415,14 @@ public class Manager implements Closeable {
                 }
             }
         }
                 }
             }
         }

+        if (message.getSticker().isPresent()) {
+            final SignalServiceDataMessage.Sticker messageSticker = message.getSticker().get();
+            Sticker sticker = account.getStickerStore().getSticker(messageSticker.getPackId());
+            if (sticker == null) {
+                sticker = new Sticker(messageSticker.getPackId(), messageSticker.getPackKey());
+                account.getStickerStore().updateSticker(sticker);
+            }
+        }

         return actions;
     }
 
         return actions;
     }
 


@@ -1553,9 +1616,7 @@ public class Manager implements Closeable {
             if (message.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) {
                 SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get();
                 GroupInfo group = getGroup(groupInfo.getGroupId());
             if (message.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) {
                 SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get();
                 GroupInfo group = getGroup(groupInfo.getGroupId());

-                if (groupInfo.getType() == SignalServiceGroup.Type.DELIVER && group != null && group.blocked) {
-                    return true;
-                }
+                return groupInfo.getType() == SignalServiceGroup.Type.DELIVER && group != null && group.isBlocked();

             }
         }
         return false;
             }
         }
         return false;


@@ -1600,7 +1661,7 @@ public class Manager implements Closeable {
                     if (rm.isBlockedListRequest()) {
                         actions.add(SendSyncBlockedListAction.create());
                     }
                     if (rm.isBlockedListRequest()) {
                         actions.add(SendSyncBlockedListAction.create());
                     }

-                    // TODO Handle rm.isConfigurationRequest();
+                    // TODO Handle rm.isConfigurationRequest(); rm.isKeysRequest();

                 }
                 if (syncMessage.getGroups().isPresent()) {
                     File tmpFile = null;
                 }
                 if (syncMessage.getGroups().isPresent()) {
                     File tmpFile = null;


@@ -1610,34 +1671,33 @@ public class Manager implements Closeable {
                             DeviceGroupsInputStream s = new DeviceGroupsInputStream(attachmentAsStream);
                             DeviceGroup g;
                             while ((g = s.read()) != null) {
                             DeviceGroupsInputStream s = new DeviceGroupsInputStream(attachmentAsStream);
                             DeviceGroup g;
                             while ((g = s.read()) != null) {

-                                GroupInfo syncGroup = account.getGroupStore().getGroup(g.getId());
-                                if (syncGroup == null) {
-                                    syncGroup = new GroupInfo(g.getId());
+                                GroupInfoV1 syncGroup = account.getGroupStore().getOrCreateGroupV1(g.getId());
+                                if (syncGroup != null) {
+                                    if (g.getName().isPresent()) {
+                                        syncGroup.name = g.getName().get();
+                                    }
+                                    syncGroup.addMembers(g.getMembers()
+                                            .stream()
+                                            .map(this::resolveSignalServiceAddress)
+                                            .collect(Collectors.toSet()));
+                                    if (!g.isActive()) {
+                                        syncGroup.removeMember(account.getSelfAddress());
+                                    } else {
+                                        // Add ourself to the member set as it's marked as active
+                                        syncGroup.addMembers(Collections.singleton(account.getSelfAddress()));
+                                    }
+                                    syncGroup.blocked = g.isBlocked();
+                                    if (g.getColor().isPresent()) {
+                                        syncGroup.color = g.getColor().get();
+                                    }
+
+                                    if (g.getAvatar().isPresent()) {
+                                        retrieveGroupAvatarAttachment(g.getAvatar().get(), syncGroup.groupId);
+                                    }
+                                    syncGroup.inboxPosition = g.getInboxPosition().orNull();
+                                    syncGroup.archived = g.isArchived();
+                                    account.getGroupStore().updateGroup(syncGroup);

                                 }
                                 }

-                                if (g.getName().isPresent()) {
-                                    syncGroup.name = g.getName().get();
-                                }
-                                syncGroup.addMembers(g.getMembers()
-                                        .stream()
-                                        .map(this::resolveSignalServiceAddress)
-                                        .collect(Collectors.toSet()));
-                                if (!g.isActive()) {
-                                    syncGroup.removeMember(account.getSelfAddress());
-                                } else {
-                                    // Add ourself to the member set as it's marked as active
-                                    syncGroup.addMembers(Collections.singleton(account.getSelfAddress()));
-                                }
-                                syncGroup.blocked = g.isBlocked();
-                                if (g.getColor().isPresent()) {
-                                    syncGroup.color = g.getColor().get();
-                                }
-
-                                if (g.getAvatar().isPresent()) {
-                                    retrieveGroupAvatarAttachment(g.getAvatar().get(), syncGroup.groupId);
-                                }
-                                syncGroup.inboxPosition = g.getInboxPosition().orNull();
-                                syncGroup.archived = g.isArchived();
-                                account.getGroupStore().updateGroup(syncGroup);

                             }
                         }
                     } catch (Exception e) {
                             }
                         }
                     } catch (Exception e) {


@@ -1727,6 +1787,23 @@ public class Manager implements Closeable {
                     final VerifiedMessage verifiedMessage = syncMessage.getVerified().get();
                     account.getSignalProtocolStore().setIdentityTrustLevel(resolveSignalServiceAddress(verifiedMessage.getDestination()), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified()));
                 }
                     final VerifiedMessage verifiedMessage = syncMessage.getVerified().get();
                     account.getSignalProtocolStore().setIdentityTrustLevel(resolveSignalServiceAddress(verifiedMessage.getDestination()), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified()));
                 }

+                if (syncMessage.getStickerPackOperations().isPresent()) {
+                    final List<StickerPackOperationMessage> stickerPackOperationMessages = syncMessage.getStickerPackOperations().get();
+                    for (StickerPackOperationMessage m : stickerPackOperationMessages) {
+                        if (!m.getPackId().isPresent()) {
+                            continue;
+                        }
+                        Sticker sticker = account.getStickerStore().getSticker(m.getPackId().get());
+                        if (sticker == null) {
+                            if (!m.getPackKey().isPresent()) {
+                                continue;
+                            }
+                            sticker = new Sticker(m.getPackId().get(), m.getPackKey().get());
+                        }
+                        sticker.setInstalled(!m.getType().isPresent() || m.getType().get() == StickerPackOperationMessage.Type.INSTALL);
+                        account.getStickerStore().updateSticker(sticker);
+                    }
+                }

                 if (syncMessage.getConfiguration().isPresent()) {
                     // TODO
                 }
                 if (syncMessage.getConfiguration().isPresent()) {
                     // TODO
                 }


@@ -1836,10 +1913,13 @@ public class Manager implements Closeable {
             try (OutputStream fos = new FileOutputStream(groupsFile)) {
                 DeviceGroupsOutputStream out = new DeviceGroupsOutputStream(fos);
                 for (GroupInfo record : account.getGroupStore().getGroups()) {
             try (OutputStream fos = new FileOutputStream(groupsFile)) {
                 DeviceGroupsOutputStream out = new DeviceGroupsOutputStream(fos);
                 for (GroupInfo record : account.getGroupStore().getGroups()) {

-                    out.write(new DeviceGroup(record.groupId, Optional.fromNullable(record.name),
-                            new ArrayList<>(record.getMembers()), createGroupAvatarAttachment(record.groupId),
-                            record.isMember(account.getSelfAddress()), Optional.of(record.messageExpirationTime),
-                            Optional.fromNullable(record.color), record.blocked, Optional.fromNullable(record.inboxPosition), record.archived));
+                    if (record instanceof GroupInfoV1) {
+                        GroupInfoV1 groupInfo = (GroupInfoV1) record;
+                        out.write(new DeviceGroup(groupInfo.groupId, Optional.fromNullable(groupInfo.name),
+                                new ArrayList<>(groupInfo.getMembers()), createGroupAvatarAttachment(groupInfo.groupId),
+                                groupInfo.isMember(account.getSelfAddress()), Optional.of(groupInfo.messageExpirationTime),
+                                Optional.fromNullable(groupInfo.color), groupInfo.blocked, Optional.fromNullable(groupInfo.inboxPosition), groupInfo.archived));
+                    }

                 }
             }
 
                 }
             }
 


@@ -1923,7 +2003,7 @@ public class Manager implements Closeable {
         }
         List<byte[]> groupIds = new ArrayList<>();
         for (GroupInfo record : account.getGroupStore().getGroups()) {
         }
         List<byte[]> groupIds = new ArrayList<>();
         for (GroupInfo record : account.getGroupStore().getGroups()) {

-            if (record.blocked) {
+            if (record.isBlocked()) {

                 groupIds.add(record.groupId);
             }
         }
                 groupIds.add(record.groupId);
             }
         }


@@ -1947,6 +2027,11 @@ public class Manager implements Closeable {
         return account.getGroupStore().getGroup(groupId);
     }
 
         return account.getGroupStore().getGroup(groupId);
     }
 

+    public byte[] getGroupId(GroupMasterKey groupMasterKey) {
+        final GroupSecretParams groupSecretParams = GroupSecretParams.deriveFromMasterKey(groupMasterKey);
+        return groupSecretParams.getPublicParams().getGroupIdentifier().serialize();
+    }
+

     public List<JsonIdentityKeyStore.Identity> getIdentities() {
         return account.getSignalProtocolStore().getIdentities();
     }
     public List<JsonIdentityKeyStore.Identity> getIdentities() {
         return account.getSignalProtocolStore().getIdentities();
     }