Merge pull request #1515 from Bilb/include-user-details-config-message

Include user details & contacts in config message

js/background.js

@@ -615,7 +615,10 @@
                   displayName: newName,
                   avatar: newAvatarPath,
                 });
-                conversation.commit();
+                await conversation.commit();
+                await window.libsession.Utils.SyncUtils.forceSyncConfigurationNowIfNeeded(
+                  true
+                );
               } catch (error) {
                 window.log.error(
                   'showEditProfileDialog Error ensuring that image is properly sized:',
@@ -627,9 +630,13 @@
               conversation.setLokiProfile({
                 displayName: newName,
               });
+              // might be good to not trigger a sync if the name did not change
+              await conversation.commit();
+              await window.libsession.Utils.SyncUtils.forceSyncConfigurationNowIfNeeded(
+                true
+              );
             }
 
-            conversation.commit();
             // inform all your registered public servers
             // could put load on all the servers
             // if they just keep changing their names without sending messages

js/models/conversations.d.ts

@@ -22,6 +22,8 @@ interface ConversationAttributes {
   is_medium_group?: boolean;
   type: string;
   lastMessage?: string;
+  avatarPointer?: string;
+  profileKey?: Uint8Array;
 }
 
 export interface ConversationModel

js/models/messages.js

@@ -1061,8 +1061,7 @@
             (dataMessage.body ||
               (dataMessage.attachments && dataMessage.attachments.length))
         );
-        const shouldNotifyPushServer =
+        const shouldNotifyPushServer = hasBodyOrAttachments && !isOurDevice;
-          hasBodyOrAttachments && isSessionOrClosedMessage;
 
         if (shouldNotifyPushServer) {
           // notify the push notification server if needed
@@ -1297,12 +1296,18 @@
         (dataMessage.body && dataMessage.body.length) ||
         dataMessage.attachments.length
       ) {
-        const syncMessage = libsession.Messages.Outgoing.ChatMessage.buildSyncMessage(
+        // try catch not to be kept
-          dataMessage,
+        try {
-          this.getConversation().id,
+          const syncMessage = libsession.Messages.Outgoing.ChatMessage.buildSyncMessage(
-          sentTimestamp
+            this.id,
-        );
+            dataMessage,
-        await libsession.getMessageQueue().sendSyncMessage(syncMessage);
+            this.getConversation().id,
+            sentTimestamp
+          );
+          await libsession.getMessageQueue().sendSyncMessage(syncMessage);
+        } catch (e) {
+          window.log.warn(e);
+        }
       }
 
       //    - copy all fields from dataMessage and create a new ChatMessage

package.json

@@ -2,7 +2,7 @@
   "name": "session-desktop",
   "productName": "Session",
   "description": "Private messaging from your desktop",
-  "version": "1.4.9",
+  "version": "1.4.10",
   "license": "GPL-3.0",
   "author": {
     "name": "Loki Project",

preload.js

@@ -494,7 +494,7 @@ const {
 
 window.BlockedNumberController = BlockedNumberController;
 window.deleteAccount = async reason => {
-  const syncedMessageSent = async () => {
+  const deleteEverything = async () => {
     window.log.info(
       'configuration message sent successfully. Deleting everything'
     );
@@ -512,14 +512,14 @@ window.deleteAccount = async reason => {
     await window.libsession.Utils.SyncUtils.forceSyncConfigurationNowIfNeeded(
       true
     );
-    await syncedMessageSent();
+    await deleteEverything();
   } catch (error) {
     window.log.error(
       'Something went wrong deleting all data:',
       error && error.stack ? error.stack : error
     );
     try {
-      await syncedMessageSent();
+      await deleteEverything();
     } catch (e) {
       window.log.error(e);
     }

protos/SignalService.proto

@@ -217,8 +217,19 @@ message ConfigurationMessage {
     repeated bytes   admins            = 5;
   }
 
+  message Contact {
+    optional bytes  publicKey         = 1;
+    optional string name              = 2;
+    optional string profilePicture    = 3;
+    optional bytes  profileKey        = 4;
+  }
+
   repeated ClosedGroup closedGroups    = 1;
   repeated string      openGroups      = 2;
+  optional string      displayName     = 3;
+  optional string      profilePicture  = 4;
+  optional bytes       profileKey      = 5;
+  repeated Contact     contacts        = 6;
 }
 
 message ReceiptMessage {

ts/session/constants.ts

@@ -5,6 +5,7 @@ export const TTL_DEFAULT = {
   TYPING_MESSAGE: 20 * SECONDS,
   REGULAR_MESSAGE: 2 * DAYS,
   ENCRYPTION_PAIR_GROUP: 4 * DAYS,
+  CONFIGURATION_MESSAGE: 4 * DAYS,
 };
 
 // User Interface

ts/session/messages/outgoing/content/ConfigurationMessage.ts

@@ -11,16 +11,28 @@ import { PubKey } from '../../../types';
 interface ConfigurationMessageParams extends MessageParams {
   activeClosedGroups: Array<ConfigurationMessageClosedGroup>;
   activeOpenGroups: Array<string>;
+  displayName: string;
+  profilePicture?: string;
+  profileKey?: Uint8Array;
+  contacts: Array<ConfigurationMessageContact>;
 }
 
 export class ConfigurationMessage extends ContentMessage {
   public readonly activeClosedGroups: Array<ConfigurationMessageClosedGroup>;
   public readonly activeOpenGroups: Array<string>;
+  public readonly displayName: string;
+  public readonly profilePicture?: string;
+  public readonly profileKey?: Uint8Array;
+  public readonly contacts: Array<ConfigurationMessageContact>;
 
   constructor(params: ConfigurationMessageParams) {
     super({ timestamp: params.timestamp, identifier: params.identifier });
     this.activeClosedGroups = params.activeClosedGroups;
     this.activeOpenGroups = params.activeOpenGroups;
+    this.displayName = params.displayName;
+    this.profilePicture = params.profilePicture;
+    this.profileKey = params.profileKey;
+    this.contacts = params.contacts;
 
     if (!this.activeClosedGroups) {
       throw new Error('closed group must be set');
@@ -29,10 +41,26 @@ export class ConfigurationMessage extends ContentMessage {
     if (!this.activeOpenGroups) {
       throw new Error('open group must be set');
     }
+
+    if (!this.displayName || !this.displayName?.length) {
+      throw new Error('displayName must be set');
+    }
+
+    if (this.profilePicture && typeof this.profilePicture !== 'string') {
+      throw new Error('profilePicture set but not an Uin8Array');
+    }
+
+    if (this.profileKey && !(this.profileKey instanceof Uint8Array)) {
+      throw new Error('profileKey set but not an Uin8Array');
+    }
+
+    if (!this.contacts) {
+      throw new Error('contacts must be set');
+    }
   }
 
   public ttl(): number {
-    return Constants.TTL_DEFAULT.TYPING_MESSAGE;
+    return Constants.TTL_DEFAULT.CONFIGURATION_MESSAGE;
   }
 
   public contentProto(): SignalService.Content {
@@ -45,15 +73,73 @@ export class ConfigurationMessage extends ContentMessage {
     return new SignalService.ConfigurationMessage({
       closedGroups: this.mapClosedGroupsObjectToProto(this.activeClosedGroups),
       openGroups: this.activeOpenGroups,
+      displayName: this.displayName,
+      profilePicture: this.profilePicture,
+      profileKey: this.profileKey,
+      contacts: this.mapContactsObjectToProto(this.contacts),
     });
   }
 
   private mapClosedGroupsObjectToProto(
     closedGroups: Array<ConfigurationMessageClosedGroup>
   ): Array<SignalService.ConfigurationMessage.ClosedGroup> {
-    return (closedGroups || []).map(m =>
+    return (closedGroups || []).map(m => m.toProto());
-      new ConfigurationMessageClosedGroup(m).toProto()
+  }
-    );
+
+  private mapContactsObjectToProto(
+    contacts: Array<ConfigurationMessageContact>
+  ): Array<SignalService.ConfigurationMessage.Contact> {
+    return (contacts || []).map(m => m.toProto());
+  }
+}
+
+export class ConfigurationMessageContact {
+  public publicKey: string;
+  public displayName: string;
+  public profilePictureURL?: string;
+  public profileKey?: Uint8Array;
+
+  public constructor({
+    publicKey,
+    displayName,
+    profilePictureURL,
+    profileKey,
+  }: {
+    publicKey: string;
+    displayName: string;
+    profilePictureURL?: string;
+    profileKey?: Uint8Array;
+  }) {
+    this.publicKey = publicKey;
+    this.displayName = displayName;
+    this.profilePictureURL = profilePictureURL;
+    this.profileKey = profileKey;
+
+    // will throw if public key is invalid
+    PubKey.cast(publicKey);
+
+    if (this.displayName?.length === 0) {
+      throw new Error('displayName must be set or undefined');
+    }
+
+    if (
+      this.profilePictureURL !== undefined &&
+      this.profilePictureURL?.length === 0
+    ) {
+      throw new Error('profilePictureURL must either undefined or not empty');
+    }
+    if (this.profileKey !== undefined && this.profileKey?.length === 0) {
+      throw new Error('profileKey must either undefined or not empty');
+    }
+  }
+
+  public toProto(): SignalService.ConfigurationMessage.Contact {
+    return new SignalService.ConfigurationMessage.Contact({
+      publicKey: fromHexToArray(this.publicKey),
+      name: this.displayName,
+      profilePicture: this.profilePictureURL,
+      profileKey: this.profileKey,
+    });
   }
 }
 

ts/session/messages/outgoing/content/data/ChatMessage.ts

@@ -91,18 +91,15 @@ export class ChatMessage extends DataMessage {
   }
 
   public static buildSyncMessage(
-    dataMessage: SignalService.IDataMessage,
+    identifier: string,
+    dataMessage: SignalService.DataMessage,
     syncTarget: string,
     sentTimestamp: number
   ) {
-    // the dataMessage.profileKey is of type ByteBuffer. We need to make it a Uint8Array
+    if (
-    const lokiProfile: any = {
+      (dataMessage as any).constructor.name !== 'DataMessage' &&
-      profileKey: new Uint8Array(
+      !(dataMessage instanceof DataMessage)
-        (dataMessage.profileKey as any).toArrayBuffer()
+    ) {
-      ),
-    };
-
-    if ((dataMessage as any)?.$type?.name !== 'DataMessage') {
       throw new Error(
         'Tried to build a sync message from something else than a DataMessage'
       );
@@ -111,6 +108,13 @@ export class ChatMessage extends DataMessage {
     if (!sentTimestamp || !isNumber(sentTimestamp)) {
       throw new Error('Tried to build a sync message without a sentTimestamp');
     }
+    // the dataMessage.profileKey is of type ByteBuffer. We need to make it a Uint8Array
+    const lokiProfile: any = {};
+    if (dataMessage.profileKey?.length) {
+      lokiProfile.profileKey = new Uint8Array(
+        (dataMessage.profileKey as any).toArrayBuffer()
+      );
+    }
 
     if (dataMessage.profile) {
       if (dataMessage.profile?.displayName) {
@@ -138,6 +142,7 @@ export class ChatMessage extends DataMessage {
     const preview = (dataMessage.preview as Array<Preview>) || [];
 
     return new ChatMessage({
+      identifier,
       timestamp,
       attachments,
       body,

ts/session/utils/Messages.ts

@@ -6,15 +6,7 @@ import {
 import { EncryptionType, PubKey } from '../types';
 import { ClosedGroupMessage } from '../messages/outgoing/content/data/group/ClosedGroupMessage';
 import { ClosedGroupNewMessage } from '../messages/outgoing/content/data/group/ClosedGroupNewMessage';
-import { ConversationModel } from '../../../js/models/conversations';
+
-import {
-  ConfigurationMessage,
-  ConfigurationMessageClosedGroup,
-} from '../messages/outgoing/content/ConfigurationMessage';
-import uuid from 'uuid';
-import { getLatestClosedGroupEncryptionKeyPair } from '../../../js/modules/data';
-import { UserUtils } from '.';
-import { ECKeyPair } from '../../receiver/keypairs';
 import _ from 'lodash';
 import { ClosedGroupEncryptionPairReplyMessage } from '../messages/outgoing/content/data/group/ClosedGroupEncryptionPairReplyMessage';
 
@@ -64,53 +56,3 @@ export async function toRawMessage(
 
   return rawMessage;
 }
-
-export const getCurrentConfigurationMessage = async (
-  convos: Array<ConversationModel>
-) => {
-  const ourPubKey = (await UserUtils.getOurNumber()).key;
-  const openGroupsIds = convos
-    .filter(c => !!c.get('active_at') && c.isPublic() && !c.get('left'))
-    .map(c => c.id.substring((c.id as string).lastIndexOf('@') + 1)) as Array<
-    string
-  >;
-  const closedGroupModels = convos.filter(
-    c =>
-      !!c.get('active_at') &&
-      c.isMediumGroup() &&
-      c.get('members').includes(ourPubKey) &&
-      !c.get('left') &&
-      !c.get('isKickedFromGroup') &&
-      !c.isBlocked()
-  );
-
-  const closedGroups = await Promise.all(
-    closedGroupModels.map(async c => {
-      const groupPubKey = c.get('id');
-      const fetchEncryptionKeyPair = await getLatestClosedGroupEncryptionKeyPair(
-        groupPubKey
-      );
-      if (!fetchEncryptionKeyPair) {
-        return null;
-      }
-
-      return new ConfigurationMessageClosedGroup({
-        publicKey: groupPubKey,
-        name: c.get('name'),
-        members: c.get('members') || [],
-        admins: c.get('groupAdmins') || [],
-        encryptionKeyPair: ECKeyPair.fromHexKeyPair(fetchEncryptionKeyPair),
-      });
-    })
-  );
-
-  const onlyValidClosedGroup = closedGroups.filter(m => m !== null) as Array<
-    ConfigurationMessageClosedGroup
-  >;
-  return new ConfigurationMessage({
-    identifier: uuid(),
-    timestamp: Date.now(),
-    activeOpenGroups: openGroupsIds,
-    activeClosedGroups: onlyValidClosedGroup,
-  });
-};

ts/session/utils/syncUtils.ts

@@ -1,9 +1,20 @@
-import { createOrUpdateItem, getItemById } from '../../../js/modules/data';
+import {
+  createOrUpdateItem,
+  getItemById,
+  getLatestClosedGroupEncryptionKeyPair,
+} from '../../../js/modules/data';
 import { getMessageQueue } from '..';
 import { ConversationController } from '../conversations';
-import { getCurrentConfigurationMessage } from './Messages';
-import { RawMessage } from '../types';
 import { DAYS } from './Number';
+import uuid from 'uuid';
+import { UserUtils } from '.';
+import { ConversationModel } from '../../../js/models/conversations';
+import { ECKeyPair } from '../../receiver/keypairs';
+import {
+  ConfigurationMessage,
+  ConfigurationMessageClosedGroup,
+  ConfigurationMessageContact,
+} from '../messages/outgoing/content/ConfigurationMessage';
 
 const ITEM_ID_LAST_SYNC_TIMESTAMP = 'lastSyncedTimestamp';
 
@@ -42,39 +53,125 @@ export const syncConfigurationIfNeeded = async () => {
 
 export const forceSyncConfigurationNowIfNeeded = async (
   waitForMessageSent = false
+) =>
+  new Promise(resolve => {
+    const allConvos = ConversationController.getInstance().getConversations();
+
+    void getCurrentConfigurationMessage(allConvos).then(configMessage => {
+      // console.warn('forceSyncConfigurationNowIfNeeded with', configMessage);
+
+      try {
+        // this just adds the message to the sending queue.
+        // if waitForMessageSent is set, we need to effectively wait until then
+        // tslint:disable-next-line: no-void-expression
+        const callback = waitForMessageSent
+          ? () => {
+            resolve(true);
+          }
+          : undefined;
+        void getMessageQueue().sendSyncMessage(configMessage, callback as any);
+        // either we resolve from the callback if we need to wait for it,
+        // or we don't want to wait, we resolve it here.
+        if (!waitForMessageSent) {
+          resolve(true);
+        }
+      } catch (e) {
+        window.log.warn(
+          'Caught an error while sending our ConfigurationMessage:',
+          e
+        );
+        resolve(false);
+      }
+    });
+  });
+
+export const getCurrentConfigurationMessage = async (
+  convos: Array<ConversationModel>
 ) => {
-  const allConvos = ConversationController.getInstance().getConversations();
+  const ourPubKey = (await UserUtils.getOurNumber()).key;
-  const configMessage = await getCurrentConfigurationMessage(allConvos);
+  const ourConvo = convos.find(convo => convo.id === ourPubKey);
-  window.log.info('forceSyncConfigurationNowIfNeeded with', configMessage);
+
-
+  // Filter open groups
-  const waitForMessageSentEvent = new Promise(resolve => {
+  const openGroupsIds = convos
-    const ourResolver = (message: any) => {
+    .filter(c => !!c.get('active_at') && c.isPublic() && !c.get('left'))
-      if (message.identifier === configMessage.identifier) {
+    .map(c => c.id.substring((c.id as string).lastIndexOf('@') + 1)) as Array<
-        getMessageQueue().events.off('sendSuccess', ourResolver);
+      string
-        getMessageQueue().events.off('sendFail', ourResolver);
+    >;
-        resolve(true);
+
+  // Filter Closed/Medium groups
+  const closedGroupModels = convos.filter(
+    c =>
+      !!c.get('active_at') &&
+      c.isMediumGroup() &&
+      c.get('members').includes(ourPubKey) &&
+      !c.get('left') &&
+      !c.get('isKickedFromGroup') &&
+      !c.isBlocked()
+  );
+
+  const closedGroups = await Promise.all(
+    closedGroupModels.map(async c => {
+      const groupPubKey = c.get('id');
+      const fetchEncryptionKeyPair = await getLatestClosedGroupEncryptionKeyPair(
+        groupPubKey
+      );
+      if (!fetchEncryptionKeyPair) {
+        return null;
       }
-    };
+
-    getMessageQueue().events.on('sendSuccess', ourResolver);
+      return new ConfigurationMessageClosedGroup({
-    getMessageQueue().events.on('sendFail', ourResolver);
+        publicKey: groupPubKey,
+        name: c.get('name'),
+        members: c.get('members') || [],
+        admins: c.get('groupAdmins') || [],
+        encryptionKeyPair: ECKeyPair.fromHexKeyPair(fetchEncryptionKeyPair),
+      });
+    })
+  );
+
+  const onlyValidClosedGroup = closedGroups.filter(m => m !== null) as Array<
+    ConfigurationMessageClosedGroup
+  >;
+
+  // Filter contacts
+  const contactsModels = convos.filter(
+    c =>
+      !!c.get('active_at') &&
+      c.getLokiProfile()?.displayName &&
+      c.isPrivate() &&
+      !c.isBlocked()
+  );
+
+  const contacts = contactsModels.map(c => {
+    return new ConfigurationMessageContact({
+      publicKey: c.id,
+      displayName: c.getLokiProfile()?.displayName,
+      profilePictureURL: c.get('avatarPointer'),
+      profileKey: c.get('profileKey'),
+    });
   });
 
-  try {
+  if (!ourConvo) {
-    // this just adds the message to the sending queue.
+    window.log.error(
-    // if waitForMessageSent is set, we need to effectively wait until then
+      'Could not find our convo while building a configuration message.'
-    await Promise.all([
-      getMessageQueue().sendSyncMessage(configMessage),
-      waitForMessageSentEvent,
-    ]);
-  } catch (e) {
-    window.log.warn(
-      'Caught an error while sending our ConfigurationMessage:',
-      e
     );
   }
-  if (!waitForMessageSent) {
+  const profileKeyFromStorage = window.storage.get('profileKey');
-    return;
+  const profileKey = profileKeyFromStorage
-  }
+    ? new Uint8Array(profileKeyFromStorage)
+    : undefined;
 
-  return waitForMessageSentEvent;
+  const profilePicture = ourConvo?.get('avatarPointer') || undefined;
+  const displayName = ourConvo?.getLokiProfile()?.displayName || undefined;
+
+  return new ConfigurationMessage({
+    identifier: uuid(),
+    timestamp: Date.now(),
+    activeOpenGroups: openGroupsIds,
+    activeClosedGroups: onlyValidClosedGroup,
+    displayName,
+    profilePicture,
+    profileKey,
+    contacts,
+  });
 };

ts/test/session/unit/messages/ConfigurationMessage_test.ts

@@ -4,9 +4,11 @@ import { ECKeyPair } from '../../../../receiver/keypairs';
 import {
   ConfigurationMessage,
   ConfigurationMessageClosedGroup,
+  ConfigurationMessageContact,
 } from '../../../../session/messages/outgoing/content/ConfigurationMessage';
 import { TestUtils } from '../../../test-utils';
 
+// tslint:disable-next-line: max-func-body-length
 describe('ConfigurationMessage', () => {
   it('throw if closed group is not set', () => {
     const activeClosedGroups = null as any;
@@ -14,6 +16,8 @@ describe('ConfigurationMessage', () => {
       activeClosedGroups,
       activeOpenGroups: [],
       timestamp: Date.now(),
+      displayName: 'displayName',
+      contacts: [],
     };
     expect(() => new ConfigurationMessage(params)).to.throw(
       'closed group must be set'
@@ -26,12 +30,52 @@ describe('ConfigurationMessage', () => {
       activeClosedGroups: [],
       activeOpenGroups,
       timestamp: Date.now(),
+      displayName: 'displayName',
+      contacts: [],
     };
     expect(() => new ConfigurationMessage(params)).to.throw(
       'open group must be set'
     );
   });
 
+  it('throw if display name is not set', () => {
+    const params = {
+      activeClosedGroups: [],
+      activeOpenGroups: [],
+      timestamp: Date.now(),
+      displayName: undefined as any,
+      contacts: [],
+    };
+    expect(() => new ConfigurationMessage(params)).to.throw(
+      'displayName must be set'
+    );
+  });
+
+  it('throw if display name is set but empty', () => {
+    const params = {
+      activeClosedGroups: [],
+      activeOpenGroups: [],
+      timestamp: Date.now(),
+      displayName: undefined as any,
+      contacts: [],
+    };
+    expect(() => new ConfigurationMessage(params)).to.throw(
+      'displayName must be set'
+    );
+  });
+
+  it('ttl is 4 days', () => {
+    const params = {
+      activeClosedGroups: [],
+      activeOpenGroups: [],
+      timestamp: Date.now(),
+      displayName: 'displayName',
+      contacts: [],
+    };
+    const configMessage = new ConfigurationMessage(params);
+    expect(configMessage.ttl()).to.be.equal(4 * 24 * 60 * 60 * 1000);
+  });
+
   describe('ConfigurationMessageClosedGroup', () => {
     it('throw if closed group has no encryptionkeypair', () => {
       const member = TestUtils.generateFakePubKey().key;
@@ -137,4 +181,92 @@ describe('ConfigurationMessage', () => {
       );
     });
   });
+
+  describe('ConfigurationMessageContact', () => {
+    it('throws if contacts is not set', () => {
+      const params = {
+        activeClosedGroups: [],
+        activeOpenGroups: [],
+        timestamp: Date.now(),
+        displayName: 'displayName',
+        contacts: undefined as any,
+      };
+      expect(() => new ConfigurationMessage(params)).to.throw(
+        'contacts must be set'
+      );
+    });
+    it('throw if some admins are not members', () => {
+      const member = TestUtils.generateFakePubKey().key;
+      const admin = TestUtils.generateFakePubKey().key;
+      const params = {
+        publicKey: TestUtils.generateFakePubKey().key,
+        name: 'groupname',
+        members: [member],
+        admins: [admin],
+        encryptionKeyPair: TestUtils.generateFakeECKeyPair(),
+      };
+
+      expect(() => new ConfigurationMessageClosedGroup(params)).to.throw(
+        'some admins are not members'
+      );
+    });
+
+    it('throw if the contact has not a valid pubkey', () => {
+      const params = {
+        publicKey: '05',
+        displayName: 'contactDisplayName',
+      };
+
+      expect(() => new ConfigurationMessageContact(params)).to.throw();
+
+      const params2 = {
+        publicKey: undefined as any,
+        displayName: 'contactDisplayName',
+      };
+
+      expect(() => new ConfigurationMessageContact(params2)).to.throw();
+    });
+
+    it('throw if the contact has an empty display name', () => {
+      // a display name cannot be empty nor undefined
+
+      const params = {
+        publicKey: TestUtils.generateFakePubKey().key,
+        displayName: undefined as any,
+      };
+
+      expect(() => new ConfigurationMessageContact(params2)).to.throw();
+
+      const params2 = {
+        publicKey: TestUtils.generateFakePubKey().key,
+        displayName: '',
+      };
+
+      expect(() => new ConfigurationMessageContact(params2)).to.throw();
+    });
+
+    it('throw if the contact has a profileAvatar set but empty', () => {
+      const params = {
+        publicKey: TestUtils.generateFakePubKey().key,
+        displayName: 'contactDisplayName',
+        profilePictureURL: '',
+      };
+
+      expect(() => new ConfigurationMessageContact(params)).to.throw(
+        'profilePictureURL must either undefined or not empty'
+      );
+    });
+
+    it('throw if the contact has a profileKey set but empty', () => {
+      const params = {
+        publicKey: TestUtils.generateFakePubKey().key,
+        displayName: 'contactDisplayName',
+        profileKey: new Uint8Array(),
+      };
+
+      expect(() => new ConfigurationMessageContact(params)).to.throw(
+        'profileKey must either undefined or not empty'
+      );
+    });
+  });
 });

ts/test/session/unit/receiving/ConfigurationMessage_test.ts

@@ -34,7 +34,9 @@ describe('ConfigurationMessage_receiving', () => {
       activeOpenGroups: [],
       activeClosedGroups: [],
       timestamp: Date.now(),
-      identifier: 'whatever',
+      identifier: 'identifier',
+      displayName: 'displayName',
+      contacts: [],
     });
   });
 

ts/test/session/unit/utils/Messages_test.ts

@@ -215,6 +215,8 @@ describe('Message Utils', () => {
         timestamp: Date.now(),
         activeOpenGroups: [],
         activeClosedGroups: [],
+        displayName: 'displayName',
+        contacts: [],
       });
       const rawMessage = await MessageUtils.toRawMessage(device, msg);
       expect(rawMessage.encryption).to.equal(EncryptionType.Fallback);