Merge remote-tracking branch 'upstream/main' into yiffed

2020-10-29 12:04:05 +03:00 · 2020-10-29 12:04:05 +03:00 · 0f5943382e
parent b515d52e0c 955fb747c2
commit 0f5943382e
25 changed files with 476 additions and 244 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -133,14 +133,14 @@ pages:
 # Adds license-scanning job. Because Gitlab does not support pub.dev
 # we added https://github.com/oss-review-toolkit/ort

-include:
-  - template: Security/License-Scanning.gitlab-ci.yml
+#include:
+#  - template: Security/License-Scanning.gitlab-ci.yml

-license_scanning:
-  stage: coverage
-  image:
-    name: "registry.gitlab.com/gitlab-org/security-products/analyzers/ort/ort:latest"
-  script:
-    - /opt/ort/bin/ort analyze -i $CI_PROJECT_DIR -o $CI_PROJECT_DIR/ --allow-dynamic-versions
-    - /opt/ort/bin/ort scan -i $CI_PROJECT_DIR/analyzer-result.yml -o $CI_PROJECT_DIR/ || true
-    - /opt/ort/bin/ort report -f GitLabLicenseModel -i $CI_PROJECT_DIR/scan-result.yml -o $CI_PROJECT_DIR/
+#license_scanning:
+#  stage: coverage
+#  image:
+#    name: "registry.gitlab.com/gitlab-org/security-products/analyzers/ort/ort:latest"
+#  script:
+#    - /opt/ort/bin/ort analyze -i $CI_PROJECT_DIR -o $CI_PROJECT_DIR/ --allow-dynamic-versions
+#    - /opt/ort/bin/ort scan -i $CI_PROJECT_DIR/analyzer-result.yml -o $CI_PROJECT_DIR/ || true
+#    - /opt/ort/bin/ort report -f GitLabLicenseModel -i $CI_PROJECT_DIR/scan-result.yml -o $CI_PROJECT_DIR/
--- a/README.md
+++ b/README.md
@ -26,45 +26,38 @@ import 'package:famedlysdk/famedlysdk.dart';
 2. Create a new client:

 ```dart
-Client matrix = Client("HappyChat");
+Client client = Client("HappyChat");
 ```

 Take a look here for an example store:
 [https://gitlab.com/ChristianPauly/fluffychat-flutter/snippets](https://gitlab.com/ChristianPauly/fluffychat-flutter/snippets)

-```dart
-Client matrix = Client("HappyChat");
-```
-
 3. Connect to a Matrix Homeserver and listen to the streams:

 ```dart
-matrix.onLoginStateChanged.stream.listen((bool loginState){ 
+client.onLoginStateChanged.stream.listen((bool loginState){ 
  print("LoginState: ${loginState.toString()}");
 });

-matrix.onEvent.stream.listen((EventUpdate eventUpdate){ 
+client.onEvent.stream.listen((EventUpdate eventUpdate){ 
  print("New event update!");
 });

-matrix.onRoomUpdate.stream.listen((RoomUpdate eventUpdate){ 
+client.onRoomUpdate.stream.listen((RoomUpdate eventUpdate){ 
  print("New room update!");
 });

-final bool serverValid = await matrix.checkServer("https://yourhomeserver.abc");
-
-final bool loginValid = await matrix.login("username", "password");
+try {
+  await client.checkHomeserver("https://yourhomeserver.abc");
+  await client.login("username", "password");
+}
+catch(e) {
+  print('No luck...');
+}
 ```

 4. Send a message to a Room:

 ```dart
-final resp = await matrix.jsonRequest(
-    type: "PUT",
-    action: "/r0/rooms/!fjd823j:example.com/send/m.room.message/$txnId",
-    data: {
-        "msgtype": "m.text",
-        "body": "hello"
-    }
-);
+await client.getRoomById('your_room_id').sendTextEvent('Hello world');
 ```
--- a/lib/encryption/encryption.dart
+++ b/lib/encryption/encryption.dart
@ -105,7 +105,7 @@ class Encryption {
  }

  Future<void> handleEventUpdate(EventUpdate update) async {
-    if (update.type == 'ephemeral') {
+    if (update.type == EventUpdateType.ephemeral) {
      return;
    }
    if (update.eventType.startsWith('m.key.verification.') ||
@ -159,17 +159,7 @@ class Encryption {
      var haveIndex = inboundGroupSession.indexes.containsKey(messageIndexKey);
      if (haveIndex &&
          inboundGroupSession.indexes[messageIndexKey] != messageIndexValue) {
-        // TODO: maybe clear outbound session, if it is ours
-        // TODO: Make it so that we can't re-request the session keys, this is just for debugging
        Logs.error('[Decrypt] Could not decrypt due to a corrupted session.');
-        Logs.error('[Decrypt] Want session: $roomId $sessionId $senderKey');
-        Logs.error(
-            '[Decrypt] Have sessoin: ${inboundGroupSession.roomId} ${inboundGroupSession.sessionId} ${inboundGroupSession.senderKey}');
-        Logs.error(
-            '[Decrypt] Want indexes: $messageIndexKey $messageIndexValue');
-        Logs.error(
-            '[Decrypt] Have indexes: $messageIndexKey ${inboundGroupSession.indexes[messageIndexKey]}');
-        canRequestSession = true;
        throw (DecryptError.CHANNEL_CORRUPTED);
      }
      inboundGroupSession.indexes[messageIndexKey] = messageIndexValue;
@ -188,13 +178,15 @@ class Encryption {
    } catch (exception) {
      // alright, if this was actually by our own outbound group session, we might as well clear it
      if (client.enableE2eeRecovery &&
+          exception != DecryptError.UNKNOWN_SESSION &&
          (keyManager
                      .getOutboundGroupSession(roomId)
                      ?.outboundGroupSession
                      ?.session_id() ??
                  '') ==
              event.content['session_id']) {
-        keyManager.clearOutboundGroupSession(roomId, wipe: true);
+        runInRoot(() =>
+            keyManager.clearOrUseOutboundGroupSession(roomId, wipe: true));
      }
      if (canRequestSession) {
        decryptedPayload = {
@ -235,8 +227,23 @@ class Encryption {
  }

  Future<Event> decryptRoomEvent(String roomId, Event event,
-      {bool store = false, String updateType = 'timeline'}) async {
-    final doStore = () async {
+      {bool store = false,
+      EventUpdateType updateType = EventUpdateType.timeline}) async {
+    if (event.type != EventTypes.Encrypted) {
+      return event;
+    }
+    if (client.database != null &&
+        keyManager.getInboundGroupSession(roomId, event.content['session_id'],
+                event.content['sender_key']) ==
+            null) {
+      await keyManager.loadInboundGroupSession(
+          roomId, event.content['session_id'], event.content['sender_key']);
+    }
+    event = decryptRoomEventSync(roomId, event);
+    if (event.type != EventTypes.Encrypted && store) {
+      if (updateType != EventUpdateType.history) {
+        event.room?.setState(event);
+      }
      await client.database?.storeEventUpdate(
        client.id,
        EventUpdate(
@ -247,28 +254,6 @@ class Encryption {
          sortOrder: event.sortOrder,
        ),
      );
-      if (updateType != 'history') {
-        event.room?.setState(event);
-      }
-    };
-    if (event.type != EventTypes.Encrypted) {
-      return event;
-    }
-    event = decryptRoomEventSync(roomId, event);
-    if (event.type != EventTypes.Encrypted) {
-      if (store) {
-        await doStore();
-      }
-      return event;
-    }
-    if (client.database == null) {
-      return event;
-    }
-    await keyManager.loadInboundGroupSession(
-        roomId, event.content['session_id'], event.content['sender_key']);
-    event = decryptRoomEventSync(roomId, event);
-    if (event.type != EventTypes.Encrypted && store) {
-      await doStore();
    }
    return event;
  }
@ -288,7 +273,7 @@ class Encryption {
    if (keyManager.getOutboundGroupSession(roomId) == null) {
      await keyManager.loadOutboundGroupSession(roomId);
    }
-    await keyManager.clearOutboundGroupSession(roomId);
+    await keyManager.clearOrUseOutboundGroupSession(roomId);
    if (keyManager.getOutboundGroupSession(roomId) == null) {
      await keyManager.createOutboundGroupSession(roomId);
    }
@ -314,7 +299,6 @@ class Encryption {
      'session_id': sess.outboundGroupSession.session_id(),
      if (mRelatesTo != null) 'm.relates_to': mRelatesTo,
    };
-    sess.sentMessages++;
    await keyManager.storeOutboundGroupSession(roomId, sess);
    return encryptedPayload;
  }
--- a/lib/encryption/key_manager.dart
+++ b/lib/encryption/key_manager.dart
@ -150,9 +150,14 @@ class KeyManager {
            .markInboundGroupSessionAsUploaded(client.id, roomId, sessionId);
      }
    });
-    // TODO: somehow try to decrypt last message again
    final room = client.getRoomById(roomId);
    if (room != null) {
+      // attempt to decrypt the last event
+      final event = room.getState(EventTypes.Encrypted);
+      if (event != null && event.content['session_id'] == sessionId) {
+        encryption.decryptRoomEvent(roomId, event, store: true);
+      }
+      // and finally broadcast the new session
      room.onSessionKeyReceived.add(sessionId);
    }
  }
@ -210,7 +215,7 @@ class KeyManager {
        // do e2ee recovery
        _requestedSessionIds.add(requestIdent);
        unawaited(runInRoot(() =>
-            request(room, sessionId, senderKey, askOnlyOwnDevices: true)));
+            request(room, sessionId, senderKey, onlineKeyBackupOnly: true)));
      }
      return null;
    }
@ -226,6 +231,18 @@ class KeyManager {
    return sess;
  }

+  Map<String, Map<String, bool>> _getDeviceKeyIdMap(
+      List<DeviceKeys> deviceKeys) {
+    final deviceKeyIds = <String, Map<String, bool>>{};
+    for (final device in deviceKeys) {
+      if (!deviceKeyIds.containsKey(device.userId)) {
+        deviceKeyIds[device.userId] = <String, bool>{};
+      }
+      deviceKeyIds[device.userId][device.deviceId] = device.blocked;
+    }
+    return deviceKeyIds;
+  }
+
  /// clear all cached inbound group sessions. useful for testing
  void clearOutboundGroupSessions() {
    _outboundGroupSessions.clear();
@ -233,8 +250,8 @@ class KeyManager {

  /// Clears the existing outboundGroupSession but first checks if the participating
  /// devices have been changed. Returns false if the session has not been cleared because
-  /// it wasn't necessary.
-  Future<bool> clearOutboundGroupSession(String roomId,
+  /// it wasn't necessary. Otherwise returns true.
+  Future<bool> clearOrUseOutboundGroupSession(String roomId,
      {bool wipe = false}) async {
    final room = client.getRoomById(roomId);
    final sess = getOutboundGroupSession(roomId);
@ -242,15 +259,7 @@ class KeyManager {
      return true;
    }
    if (!wipe) {
-      // first check if the devices in the room changed
-      final deviceKeys = await room.getUserDeviceKeys();
-      deviceKeys.removeWhere((k) => k.blocked);
-      final deviceKeyIds = deviceKeys.map((k) => k.deviceId).toList();
-      deviceKeyIds.sort();
-      if (deviceKeyIds.toString() != sess.devices.toString()) {
-        wipe = true;
-      }
-      // next check if it needs to be rotated
+      // first check if it needs to be rotated
      final encryptionContent = room.getState(EventTypes.Encryption)?.content;
      final maxMessages = encryptionContent != null &&
              encryptionContent['rotation_period_msgs'] is int
@ -266,7 +275,76 @@ class KeyManager {
              .isBefore(DateTime.now())) {
        wipe = true;
      }
+    }
    if (!wipe) {
+      // next check if the devices in the room changed
+      final devicesToReceive = <DeviceKeys>[];
+      final newDeviceKeys = await room.getUserDeviceKeys();
+      final newDeviceKeyIds = _getDeviceKeyIdMap(newDeviceKeys);
+      // first check for user differences
+      final oldUserIds = Set.from(sess.devices.keys);
+      final newUserIds = Set.from(newDeviceKeyIds.keys);
+      if (oldUserIds.difference(newUserIds).isNotEmpty) {
+        // a user left the room, we must wipe the session
+        wipe = true;
+      } else {
+        final newUsers = newUserIds.difference(oldUserIds);
+        if (newUsers.isNotEmpty) {
+          // new user! Gotta send the megolm session to them
+          devicesToReceive
+              .addAll(newDeviceKeys.where((d) => newUsers.contains(d.userId)));
+        }
+        // okay, now we must test all the individual user devices, if anything new got blocked
+        // or if we need to send to any new devices.
+        // for this it is enough if we iterate over the old user Ids, as the new ones already have the needed keys in the list.
+        // we also know that all the old user IDs appear in the old one, else we have already wiped the session
+        for (final userId in oldUserIds) {
+          final oldBlockedDevices = Set.from(sess.devices[userId].entries
+              .where((e) => e.value)
+              .map((e) => e.key));
+          final newBlockedDevices = Set.from(newDeviceKeyIds[userId]
+              .entries
+              .where((e) => e.value)
+              .map((e) => e.key));
+          // we don't really care about old devices that got dropped (deleted), we only care if new ones got added and if new ones got blocked
+          // check if new devices got blocked
+          if (newBlockedDevices.difference(oldBlockedDevices).isNotEmpty) {
+            wipe = true;
+            break;
+          }
+          // and now add all the new devices!
+          final oldDeviceIds = Set.from(sess.devices[userId].keys);
+          final newDeviceIds = Set.from(newDeviceKeyIds[userId].keys);
+          final newDevices = newDeviceIds.difference(oldDeviceIds);
+          if (newDeviceIds.isNotEmpty) {
+            devicesToReceive.addAll(newDeviceKeys.where(
+                (d) => d.userId == userId && newDevices.contains(d.deviceId)));
+          }
+        }
+      }
+
+      if (!wipe) {
+        // okay, we use the outbound group session!
+        sess.sentMessages++;
+        sess.devices = newDeviceKeyIds;
+        final rawSession = <String, dynamic>{
+          'algorithm': 'm.megolm.v1.aes-sha2',
+          'room_id': room.id,
+          'session_id': sess.outboundGroupSession.session_id(),
+          'session_key': sess.outboundGroupSession.session_key(),
+        };
+        try {
+          devicesToReceive.removeWhere((k) => k.blocked);
+          if (devicesToReceive.isNotEmpty) {
+            await client.sendToDeviceEncrypted(
+                devicesToReceive, 'm.room_key', rawSession);
+          }
+        } catch (e, s) {
+          Logs.error(
+              '[LibOlm] Unable to re-send the session key at later index to new devices: ' +
+                  e.toString(),
+              s);
+        }
        return false;
      }
    }
@ -291,15 +369,13 @@ class KeyManager {
  }

  Future<OutboundGroupSession> createOutboundGroupSession(String roomId) async {
-    await clearOutboundGroupSession(roomId, wipe: true);
+    await clearOrUseOutboundGroupSession(roomId, wipe: true);
    final room = client.getRoomById(roomId);
    if (room == null) {
      return null;
    }
    final deviceKeys = await room.getUserDeviceKeys();
-    deviceKeys.removeWhere((k) => k.blocked);
-    final deviceKeyIds = deviceKeys.map((k) => k.deviceId).toList();
-    deviceKeyIds.sort();
+    final deviceKeyIds = _getDeviceKeyIdMap(deviceKeys);
    final outboundGroupSession = olm.OutboundGroupSession();
    try {
      outboundGroupSession.create();
@ -326,6 +402,7 @@ class KeyManager {
      key: client.userID,
    );
    try {
+      deviceKeys.removeWhere((k) => k.blocked);
      await client.sendToDeviceEncrypted(deviceKeys, 'm.room_key', rawSession);
      await storeOutboundGroupSession(roomId, sess);
      _outboundGroupSessions[roomId] = sess;
@ -467,7 +544,7 @@ class KeyManager {
    String sessionId,
    String senderKey, {
    bool tryOnlineBackup = true,
-    bool askOnlyOwnDevices = false,
+    bool onlineKeyBackupOnly = false,
  }) async {
    if (tryOnlineBackup && await isCached()) {
      // let's first check our online key backup store thingy...
@ -491,13 +568,13 @@ class KeyManager {
        return; // we managed to load the session from online backup, no need to care about it now
      }
    }
+    if (onlineKeyBackupOnly) {
+      return; // we only want to do the online key backup
+    }
    try {
      // while we just send the to-device event to '*', we still need to save the
      // devices themself to know where to send the cancel to after receiving a reply
      final devices = await room.getUserDeviceKeys();
-      if (askOnlyOwnDevices) {
-        devices.removeWhere((d) => d.userId != client.userID);
-      }
      final requestId = client.generateUniqueTransactionId();
      final request = KeyManagerKeyShareRequest(
        requestId: requestId,
--- a/lib/encryption/utils/outbound_group_session.dart
+++ b/lib/encryption/utils/outbound_group_session.dart
@ -24,7 +24,11 @@ import '../../src/database/database.dart' show DbOutboundGroupSession;
 import '../../src/utils/logs.dart';

 class OutboundGroupSession {
-  List<String> devices;
+  /// The devices is a map from user id to device id to if the device is blocked.
+  /// This way we can easily know if a new user is added, leaves, a new devices is added, and,
+  /// very importantly, if we block a device. These are all important for determining if/when
+  /// an outbound session needs to be rotated.
+  Map<String, Map<String, bool>> devices;
  DateTime creationTime;
  olm.OutboundGroupSession outboundGroupSession;
  int sentMessages;
@ -40,10 +44,21 @@ class OutboundGroupSession {

  OutboundGroupSession.fromDb(DbOutboundGroupSession dbEntry, String key)
      : key = key {
+    try {
+      devices = {};
+      for (final entry in json.decode(dbEntry.deviceIds).entries) {
+        devices[entry.key] = Map<String, bool>.from(entry.value);
+      }
+    } catch (e) {
+      // devices is bad (old data), so just not use this session
+      Logs.info(
+          '[OutboundGroupSession] Session in database is old, not using it. ' +
+              e.toString());
+      return;
+    }
    outboundGroupSession = olm.OutboundGroupSession();
    try {
      outboundGroupSession.unpickle(key, dbEntry.pickle);
-      devices = List<String>.from(json.decode(dbEntry.deviceIds));
      creationTime = DateTime.fromMillisecondsSinceEpoch(dbEntry.creationTime);
      sentMessages = dbEntry.sentMessages;
    } catch (e, s) {
--- a/lib/src/client.dart
+++ b/lib/src/client.dart
@ -256,43 +256,51 @@ class Client extends MatrixApi {
    return wellKnown;
  }

-  /// Checks the supported versions of the Matrix protocol and the supported
-  /// login types. Returns false if the server is not compatible with the
-  /// client.
-  /// Throws FormatException, TimeoutException and MatrixException on error.
+  @Deprecated('Use [checkHomeserver] instead.')
  Future<bool> checkServer(dynamic serverUrl) async {
    try {
-      if (serverUrl is Uri) {
-        homeserver = serverUrl;
+      await checkHomeserver(serverUrl);
+    } catch (_) {
+      return false;
+    }
+    return true;
+  }
+
+  /// Checks the supported versions of the Matrix protocol and the supported
+  /// login types. Throws an exception if the server is not compatible with the
+  /// client and sets [homeserver] to [serverUrl] if it is. Supports the types [Uri]
+  /// and [String].
+  Future<void> checkHomeserver(dynamic homeserverUrl,
+      {Set<String> supportedLoginTypes = supportedLoginTypes}) async {
+    try {
+      if (homeserverUrl is Uri) {
+        homeserver = homeserverUrl;
      } else {
        // URLs allow to have whitespace surrounding them, see https://www.w3.org/TR/2011/WD-html5-20110525/urls.html
        // As we want to strip a trailing slash, though, we have to trim the url ourself
        // and thus can't let Uri.parse() deal with it.
-        serverUrl = serverUrl.trim();
+        homeserverUrl = homeserverUrl.trim();
        // strip a trailing slash
-        if (serverUrl.endsWith('/')) {
-          serverUrl = serverUrl.substring(0, serverUrl.length - 1);
+        if (homeserverUrl.endsWith('/')) {
+          homeserverUrl = homeserverUrl.substring(0, homeserverUrl.length - 1);
        }
-        homeserver = Uri.parse(serverUrl);
+        homeserver = Uri.parse(homeserverUrl);
      }
      final versions = await requestSupportedVersions();

-      for (var i = 0; i < versions.versions.length; i++) {
-        if (versions.versions[i] == 'r0.5.0' ||
-            versions.versions[i] == 'r0.6.0') {
-          break;
-        } else if (i == versions.versions.length - 1) {
-          return false;
-        }
+      if (!versions.versions
+          .any((version) => supportedVersions.contains(version))) {
+        throw Exception(
+            'Server supports the versions: ${versions.versions.toString()} but this application is only compatible with ${supportedVersions.toString()}.');
      }

      final loginTypes = await requestLoginTypes();
-      if (loginTypes.flows.indexWhere((f) => f.type == 'm.login.password') ==
-          -1) {
-        return false;
+      if (!loginTypes.flows.any((f) => supportedLoginTypes.contains(f.type))) {
+        throw Exception(
+            'Server supports the Login Types: ${loginTypes.flows.map((f) => f.toJson).toList().toString()} but this application is only compatible with ${supportedLoginTypes.toString()}.');
      }

-      return true;
+      return;
    } catch (_) {
      homeserver = null;
      rethrow;
@ -301,7 +309,7 @@ class Client extends MatrixApi {

  /// Checks to see if a username is available, and valid, for the server.
  /// Returns the fully-qualified Matrix user ID (MXID) that has been registered.
-  /// You have to call [checkServer] first to set a homeserver.
+  /// You have to call [checkHomeserver] first to set a homeserver.
  @override
  Future<LoginResponse> register({
    String username,
@ -339,7 +347,7 @@ class Client extends MatrixApi {
  /// Handles the login and allows the client to call all APIs which require
  /// authentication. Returns false if the login was not successful. Throws
  /// MatrixException if login was not successful.
-  /// You have to call [checkServer] first to set a homeserver.
+  /// You have to call [checkHomeserver] first to set a homeserver.
  @override
  Future<LoginResponse> login({
    String type = 'm.login.password',
@ -503,8 +511,11 @@ class Client extends MatrixApi {
      ? PushRuleSet.fromJson(accountData['m.push_rules'].content)
      : null;

-  static String syncFilters = '{"room":{"state":{"lazy_load_members":true}}}';
-  static String messagesFilters = '{"lazy_load_members":true}';
+  static const Set<String> supportedVersions = {'r0.5.0', 'r0.6.0'};
+  static const Set<String> supportedLoginTypes = {'m.login.password'};
+  static const String syncFilters =
+      '{"room":{"state":{"lazy_load_members":true}}}';
+  static const String messagesFilters = '{"lazy_load_members":true}';
  static const List<String> supportedDirectEncryptionAlgorithms = [
    'm.olm.v1.curve25519-aes-sha2'
  ];
@ -911,14 +922,16 @@ class Client extends MatrixApi {
        if (room.state?.isNotEmpty ?? false) {
          // TODO: This method seems to be comperatively slow for some updates
          await _handleRoomEvents(
-              id, room.state.map((i) => i.toJson()).toList(), 'state');
+              id,
+              room.state.map((i) => i.toJson()).toList(),
+              EventUpdateType.state);
          handledEvents = true;
        }
        if (room.timeline?.events?.isNotEmpty ?? false) {
          await _handleRoomEvents(
              id,
              room.timeline.events.map((i) => i.toJson()).toList(),
-              sortAtTheEnd ? 'history' : 'timeline',
+              sortAtTheEnd ? EventUpdateType.history : EventUpdateType.timeline,
              sortAtTheEnd: sortAtTheEnd);
          handledEvents = true;
        }
@ -928,30 +941,40 @@ class Client extends MatrixApi {
              id, room.ephemeral.map((i) => i.toJson()).toList());
        }
        if (room.accountData?.isNotEmpty ?? false) {
-          await _handleRoomEvents(id,
-              room.accountData.map((i) => i.toJson()).toList(), 'account_data');
+          await _handleRoomEvents(
+              id,
+              room.accountData.map((i) => i.toJson()).toList(),
+              EventUpdateType.accountData);
        }
      }
      if (room is LeftRoomUpdate) {
        if (room.timeline?.events?.isNotEmpty ?? false) {
-          await _handleRoomEvents(id,
-              room.timeline.events.map((i) => i.toJson()).toList(), 'timeline');
+          await _handleRoomEvents(
+              id,
+              room.timeline.events.map((i) => i.toJson()).toList(),
+              EventUpdateType.timeline);
          handledEvents = true;
        }
        if (room.accountData?.isNotEmpty ?? false) {
-          await _handleRoomEvents(id,
-              room.accountData.map((i) => i.toJson()).toList(), 'account_data');
+          await _handleRoomEvents(
+              id,
+              room.accountData.map((i) => i.toJson()).toList(),
+              EventUpdateType.accountData);
        }
        if (room.state?.isNotEmpty ?? false) {
          await _handleRoomEvents(
-              id, room.state.map((i) => i.toJson()).toList(), 'state');
+              id,
+              room.state.map((i) => i.toJson()).toList(),
+              EventUpdateType.state);
          handledEvents = true;
        }
      }
      if (room is InvitedRoomUpdate &&
          (room.inviteState?.isNotEmpty ?? false)) {
-        await _handleRoomEvents(id,
-            room.inviteState.map((i) => i.toJson()).toList(), 'invite_state');
+        await _handleRoomEvents(
+            id,
+            room.inviteState.map((i) => i.toJson()).toList(),
+            EventUpdateType.inviteState);
      }
      if (handledEvents && database != null && roomObj != null) {
        await roomObj.updateSortOrder();
@ -961,7 +984,7 @@ class Client extends MatrixApi {

  Future<void> _handleEphemerals(String id, List<dynamic> events) async {
    for (num i = 0; i < events.length; i++) {
-      await _handleEvent(events[i], id, 'ephemeral');
+      await _handleEvent(events[i], id, EventUpdateType.ephemeral);

      // Receipt events are deltas between two states. We will create a
      // fake room account data event for this and store the difference
@ -998,13 +1021,13 @@ class Client extends MatrixApi {
          }
        }
        events[i]['content'] = receiptStateContent;
-        await _handleEvent(events[i], id, 'account_data');
+        await _handleEvent(events[i], id, EventUpdateType.accountData);
      }
    }
  }

  Future<void> _handleRoomEvents(
-      String chat_id, List<dynamic> events, String type,
+      String chat_id, List<dynamic> events, EventUpdateType type,
      {bool sortAtTheEnd = false}) async {
    for (num i = 0; i < events.length; i++) {
      await _handleEvent(events[i], chat_id, type, sortAtTheEnd: sortAtTheEnd);
@ -1012,7 +1035,7 @@ class Client extends MatrixApi {
  }

  Future<void> _handleEvent(
-      Map<String, dynamic> event, String roomID, String type,
+      Map<String, dynamic> event, String roomID, EventUpdateType type,
      {bool sortAtTheEnd = false}) async {
    if (event['type'] is String && event['content'] is Map<String, dynamic>) {
      // The client must ignore any new m.room.encryption event to prevent
@ -1028,7 +1051,7 @@ class Client extends MatrixApi {

      // ephemeral events aren't persisted and don't need a sort order - they are
      // expected to be processed as soon as they come in
-      final sortOrder = type != 'ephemeral'
+      final sortOrder = type != EventUpdateType.ephemeral
          ? (sortAtTheEnd ? room.oldSortOrder : room.newSortOrder)
          : 0.0;
      var update = EventUpdate(
@ -1051,7 +1074,7 @@ class Client extends MatrixApi {
          room.setState(user);
        }
      }
-      if (type != 'ephemeral' && database != null) {
+      if (type != EventUpdateType.ephemeral && database != null) {
        await database.storeEventUpdate(id, update);
      }
      _updateRoomsByEventUpdate(update);
@ -1062,7 +1085,7 @@ class Client extends MatrixApi {

      final rawUnencryptedEvent = update.content;

-      if (prevBatch != null && type == 'timeline') {
+      if (prevBatch != null && type == EventUpdateType.timeline) {
        if (rawUnencryptedEvent['type'] == EventTypes.CallInvite) {
          onCallInvite
              .add(Event.fromJson(rawUnencryptedEvent, room, sortOrder));
@ -1141,15 +1164,15 @@ class Client extends MatrixApi {
  }

  void _updateRoomsByEventUpdate(EventUpdate eventUpdate) {
-    if (eventUpdate.type == 'history') return;
+    if (eventUpdate.type == EventUpdateType.history) return;

    final room = getRoomById(eventUpdate.roomID);
    if (room == null) return;

    switch (eventUpdate.type) {
-      case 'timeline':
-      case 'state':
-      case 'invite_state':
+      case EventUpdateType.timeline:
+      case EventUpdateType.state:
+      case EventUpdateType.inviteState:
        var stateEvent =
            Event.fromJson(eventUpdate.content, room, eventUpdate.sortOrder);
        var prevState = room.getState(stateEvent.type, stateEvent.stateKey);
@ -1175,14 +1198,16 @@ sort order of ${prevState.sortOrder}. This should never happen...''');
          room.setState(stateEvent);
        }
        break;
-      case 'account_data':
+      case EventUpdateType.accountData:
        room.roomAccountData[eventUpdate.eventType] =
            BasicRoomEvent.fromJson(eventUpdate.content);
        break;
-      case 'ephemeral':
+      case EventUpdateType.ephemeral:
        room.ephemerals[eventUpdate.eventType] =
            BasicRoomEvent.fromJson(eventUpdate.content);
        break;
+      case EventUpdateType.history:
+        break;
    }
    room.onUpdate.add(room.id);
  }
--- a/lib/src/database/database.dart
+++ b/lib/src/database/database.dart
@ -6,7 +6,6 @@ import 'package:olm/olm.dart' as olm;

 import '../../famedlysdk.dart' as sdk;
 import '../../matrix_api.dart' as api;
-import '../../matrix_api.dart';
 import '../client.dart';
 import '../room.dart';
 import '../utils/logs.dart';
@ -266,13 +265,13 @@ class Database extends _$Database {
      // let's see if we need any m.room.member events
      final membersToPostload = <String>{};
      // the lastEvent message preview might have an author we need to fetch, if it is a group chat
-      if (room.getState(EventTypes.Message) != null && !room.isDirectChat) {
-        membersToPostload.add(room.getState(EventTypes.Message).senderId);
+      if (room.getState(api.EventTypes.Message) != null && !room.isDirectChat) {
+        membersToPostload.add(room.getState(api.EventTypes.Message).senderId);
      }
      // if the room has no name and no canonical alias, its name is calculated
      // based on the heroes of the room
-      if (room.getState(EventTypes.RoomName) == null &&
-          room.getState(EventTypes.RoomCanonicalAlias) == null &&
+      if (room.getState(api.EventTypes.RoomName) == null &&
+          room.getState(api.EventTypes.RoomCanonicalAlias) == null &&
          room.mHeroes != null) {
        // we don't have a name and no canonical alias, so we'll need to
        // post-load the heroes
@ -430,7 +429,7 @@ class Database extends _$Database {
  /// [transaction].
  Future<void> storeEventUpdate(
      int clientId, sdk.EventUpdate eventUpdate) async {
-    if (eventUpdate.type == 'ephemeral') return;
+    if (eventUpdate.type == sdk.EventUpdateType.ephemeral) return;
    final eventContent = eventUpdate.content;
    final type = eventUpdate.type;
    final chatId = eventUpdate.roomID;
@ -441,11 +440,12 @@ class Database extends _$Database {
      stateKey = eventContent['state_key'];
    }

-    if (eventUpdate.eventType == EventTypes.Redaction) {
+    if (eventUpdate.eventType == api.EventTypes.Redaction) {
      await redactMessage(clientId, eventUpdate);
    }

-    if (type == 'timeline' || type == 'history') {
+    if (type == sdk.EventUpdateType.timeline ||
+        type == sdk.EventUpdateType.history) {
      // calculate the status
      var status = 2;
      if (eventContent['unsigned'] is Map<String, dynamic> &&
@ -493,7 +493,7 @@ class Database extends _$Database {
      }
      if (storeNewEvent) {
        DbEvent oldEvent;
-        if (type == 'history') {
+        if (type == sdk.EventUpdateType.history) {
          final allOldEvents =
              await getEvent(clientId, eventContent['event_id'], chatId).get();
          if (allOldEvents.isNotEmpty) {
@ -527,12 +527,15 @@ class Database extends _$Database {
      }
    }

-    if (type == 'history') return;
+    if (type == sdk.EventUpdateType.history) return;

-    if (type != 'account_data' &&
+    if (type != sdk.EventUpdateType.accountData &&
        ((stateKey is String) ||
-            [EventTypes.Message, EventTypes.Sticker, EventTypes.Encrypted]
-                .contains(eventUpdate.eventType))) {
+            [
+              api.EventTypes.Message,
+              api.EventTypes.Sticker,
+              api.EventTypes.Encrypted
+            ].contains(eventUpdate.eventType))) {
      final now = DateTime.now();
      await storeRoomState(
        clientId,
@ -547,7 +550,7 @@ class Database extends _$Database {
        json.encode(eventContent['prev_content'] ?? ''),
        stateKey ?? '',
      );
-    } else if (type == 'account_data') {
+    } else if (type == sdk.EventUpdateType.accountData) {
      await storeRoomAccountData(
        clientId,
        eventContent['type'],
--- a/lib/src/event.dart
+++ b/lib/src/event.dart
@ -316,7 +316,7 @@ class Event extends MatrixEvent {

      room.client.onEvent.add(EventUpdate(
          roomID: room.id,
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          eventType: type,
          content: {
            'event_id': eventId,
--- a/lib/src/room.dart
+++ b/lib/src/room.dart
@ -272,7 +272,15 @@ class Room {

    var lastEvent = lastEvents.isEmpty
        ? null
-        : lastEvents.reduce((a, b) => a.sortOrder > b.sortOrder ? a : b);
+        : lastEvents.reduce((a, b) {
+            if (a.sortOrder == b.sortOrder) {
+              // if two events have the same sort order we want to give encrypted events a lower priority
+              // This is so that if the same event exists in the state both encrypted *and* unencrypted,
+              // the unencrypted one is picked
+              return a.type == EventTypes.Encrypted ? b : a;
+            }
+            return a.sortOrder > b.sortOrder ? a : b;
+          });
    if (lastEvent == null) {
      states.forEach((final String key, final entry) {
        if (!entry.containsKey('')) return;
@ -1190,7 +1198,7 @@ class Room {
        EventUpdate(
            content: content,
            roomID: id,
-            type: 'state',
+            type: EventUpdateType.state,
            eventType: EventTypes.RoomMember,
            sortOrder: 0.0),
      );
--- a/lib/src/timeline.dart
+++ b/lib/src/timeline.dart
@ -118,7 +118,6 @@ class Timeline {
      for (var i = 0; i < events.length; i++) {
        if (events[i].type == EventTypes.Encrypted &&
            events[i].messageType == MessageTypes.BadEncrypted &&
-            events[i].content['can_request_session'] == true &&
            events[i].content['session_id'] == sessionId) {
          events[i] = await room.client.encryption
              .decryptRoomEvent(room.id, events[i], store: true);
@ -211,7 +210,8 @@ class Timeline {
    try {
      if (eventUpdate.roomID != room.id) return;

-      if (eventUpdate.type == 'timeline' || eventUpdate.type == 'history') {
+      if (eventUpdate.type == EventUpdateType.timeline ||
+          eventUpdate.type == EventUpdateType.history) {
        var status = eventUpdate.content['status'] ??
            (eventUpdate.content['unsigned'] is Map<String, dynamic>
                ? eventUpdate.content['unsigned'][MessageSendingStatusKey]
@ -252,7 +252,7 @@ class Timeline {
            var newEvent = Event.fromJson(
                eventUpdate.content, room, eventUpdate.sortOrder);

-            if (eventUpdate.type == 'history' &&
+            if (eventUpdate.type == EventUpdateType.history &&
                events.indexWhere(
                        (e) => e.eventId == eventUpdate.content['event_id']) !=
                    -1) return;
--- a/lib/src/utils/event_update.dart
+++ b/lib/src/utils/event_update.dart
@ -20,11 +20,20 @@ import '../../famedlysdk.dart';
 import '../../matrix_api.dart';
 import 'logs.dart';

+enum EventUpdateType {
+  timeline,
+  state,
+  history,
+  accountData,
+  ephemeral,
+  inviteState
+}
+
 /// Represents a new event (e.g. a message in a room) or an update for an
 /// already known event.
 class EventUpdate {
  /// Usually 'timeline', 'state' or whatever.
-  final String type;
+  final EventUpdateType type;

  /// Most events belong to a room. If not, this equals to eventType.
  final String roomID;
--- a/lib/src/utils/markdown.dart
+++ b/lib/src/utils/markdown.dart
@ -76,12 +76,13 @@ class EmoteSyntax extends InlineSyntax {
  }
 }

-class InlineLatexSyntax extends InlineSyntax {
-  InlineLatexSyntax() : super(r'(?<=\s|^)\$(?=\S)([^\n$]+)(?<=\S)\$(?=\s|$)');
+class InlineLatexSyntax extends TagSyntax {
+  InlineLatexSyntax() : super(r'\$', requiresDelimiterRun: true);

  @override
-  bool onMatch(InlineParser parser, Match match) {
-    final latex = htmlEscape.convert(match[1]);
+  bool onMatchEnd(InlineParser parser, Match match, TagState state) {
+    final latex =
+        htmlEscape.convert(parser.source.substring(state.endPos, match.start));
    final element = Element('span', [Element.text('code', latex)]);
    element.attributes['data-mx-maths'] = latex;
    parser.addNode(element);
@ -89,22 +90,28 @@ class InlineLatexSyntax extends InlineSyntax {
  }
 }

+// We also want to allow single-lines of like "$$latex$$"
 class BlockLatexSyntax extends BlockSyntax {
  @override
-  RegExp get pattern => RegExp(r'^[ ]{0,3}\${2}\s*$');
+  RegExp get pattern => RegExp(r'^[ ]{0,3}\$\$(.*)$');
+
+  final endPattern = RegExp(r'^(.*)\$\$\s*$');

  @override
  List<String> parseChildLines(BlockParser parser) {
    var childLines = <String>[];
-    parser.advance();
+    var first = true;
    while (!parser.isDone) {
-      if (!pattern.hasMatch(parser.current)) {
+      final match = endPattern.firstMatch(parser.current);
+      if (match == null || (first && match.group(1).trim().isEmpty)) {
        childLines.add(parser.current);
        parser.advance();
      } else {
+        childLines.add(match.group(1));
        parser.advance();
        break;
      }
+      first = false;
    }
    return childLines;
  }
@ -112,7 +119,9 @@ class BlockLatexSyntax extends BlockSyntax {
  @override
  Node parse(BlockParser parser) {
    final childLines = parseChildLines(parser);
-    final latex = htmlEscape.convert(childLines.join('\n'));
+    // we use .substring(2) as childLines will *always* contain the first two '$$'
+    final latex =
+        htmlEscape.convert(childLines.join('\n').trim().substring(2).trim());
    final element = Element('div', [
      Element('pre', [Element.text('code', latex)])
    ]);
--- a/test/client_test.dart
+++ b/test/client_test.dart
@ -77,11 +77,11 @@ void main() {
      expect(matrix.homeserver, null);

      try {
-        await matrix.checkServer('https://fakeserver.wrongaddress');
+        await matrix.checkHomeserver('https://fakeserver.wrongaddress');
      } on FormatException catch (exception) {
        expect(exception != null, true);
      }
-      await matrix.checkServer('https://fakeserver.notexisting');
+      await matrix.checkHomeserver('https://fakeserver.notexisting');
      expect(matrix.homeserver.toString(), 'https://fakeserver.notexisting');

      final available = await matrix.usernameAvailable('testuser');
@ -240,55 +240,55 @@ void main() {

      expect(eventUpdateList[0].eventType, 'm.room.member');
      expect(eventUpdateList[0].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[0].type, 'state');
+      expect(eventUpdateList[0].type, EventUpdateType.state);

      expect(eventUpdateList[1].eventType, 'm.room.canonical_alias');
      expect(eventUpdateList[1].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[1].type, 'state');
+      expect(eventUpdateList[1].type, EventUpdateType.state);

      expect(eventUpdateList[2].eventType, 'm.room.encryption');
      expect(eventUpdateList[2].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[2].type, 'state');
+      expect(eventUpdateList[2].type, EventUpdateType.state);

      expect(eventUpdateList[3].eventType, 'm.room.pinned_events');
      expect(eventUpdateList[3].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[3].type, 'state');
+      expect(eventUpdateList[3].type, EventUpdateType.state);

      expect(eventUpdateList[4].eventType, 'm.room.member');
      expect(eventUpdateList[4].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[4].type, 'timeline');
+      expect(eventUpdateList[4].type, EventUpdateType.timeline);

      expect(eventUpdateList[5].eventType, 'm.room.message');
      expect(eventUpdateList[5].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[5].type, 'timeline');
+      expect(eventUpdateList[5].type, EventUpdateType.timeline);

      expect(eventUpdateList[6].eventType, 'm.typing');
      expect(eventUpdateList[6].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[6].type, 'ephemeral');
+      expect(eventUpdateList[6].type, EventUpdateType.ephemeral);

      expect(eventUpdateList[7].eventType, 'm.receipt');
      expect(eventUpdateList[7].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[7].type, 'ephemeral');
+      expect(eventUpdateList[7].type, EventUpdateType.ephemeral);

      expect(eventUpdateList[8].eventType, 'm.receipt');
      expect(eventUpdateList[8].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[8].type, 'account_data');
+      expect(eventUpdateList[8].type, EventUpdateType.accountData);

      expect(eventUpdateList[9].eventType, 'm.tag');
      expect(eventUpdateList[9].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[9].type, 'account_data');
+      expect(eventUpdateList[9].type, EventUpdateType.accountData);

      expect(eventUpdateList[10].eventType, 'org.example.custom.room.config');
      expect(eventUpdateList[10].roomID, '!726s6s6q:example.com');
-      expect(eventUpdateList[10].type, 'account_data');
+      expect(eventUpdateList[10].type, EventUpdateType.accountData);

      expect(eventUpdateList[11].eventType, 'm.room.name');
      expect(eventUpdateList[11].roomID, '!696r7674:example.com');
-      expect(eventUpdateList[11].type, 'invite_state');
+      expect(eventUpdateList[11].type, EventUpdateType.inviteState);

      expect(eventUpdateList[12].eventType, 'm.room.member');
      expect(eventUpdateList[12].roomID, '!696r7674:example.com');
-      expect(eventUpdateList[12].type, 'invite_state');
+      expect(eventUpdateList[12].type, EventUpdateType.inviteState);
    });

    test('To Device Update Test', () async {
@ -311,12 +311,11 @@ void main() {

      roomUpdateListFuture = matrix.onRoomUpdate.stream.toList();
      eventUpdateListFuture = matrix.onEvent.stream.toList();
-      final checkResp =
-          await matrix.checkServer('https://fakeServer.notExisting');
+
+      await matrix.checkHomeserver('https://fakeServer.notExisting');

      final loginResp = await matrix.login(user: 'test', password: '1234');

-      expect(checkResp, true);
      expect(loginResp != null, true);
    });

--- a/test/encryption/encrypt_decrypt_to_device_test.dart
+++ b/test/encryption/encrypt_decrypt_to_device_test.dart
@ -50,7 +50,7 @@ void main() {
    test('setupClient', () async {
      client = await getClient();
      otherClient.database = client.database;
-      await otherClient.checkServer('https://fakeServer.notExisting');
+      await otherClient.checkHomeserver('https://fakeServer.notExisting');
      otherClient.connect(
        newToken: 'abc',
        newUserID: '@othertest:fakeServer.notExisting',
--- a/test/encryption/key_manager_test.dart
+++ b/test/encryption/key_manager_test.dart
@ -16,6 +16,8 @@
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

+import 'dart:convert';
+
 import 'package:famedlysdk/famedlysdk.dart';
 import 'package:famedlysdk/src/utils/logs.dart';
 import 'package:test/test.dart';
@ -100,7 +102,7 @@ void main() {
      expect(
          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
          true);
-      await client.encryption.keyManager.clearOutboundGroupSession(roomId);
+      await client.encryption.keyManager.clearOrUseOutboundGroupSession(roomId);
      expect(
          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
          true);
@ -112,17 +114,17 @@ void main() {

      // rotate after too many messages
      sess.sentMessages = 300;
-      await client.encryption.keyManager.clearOutboundGroupSession(roomId);
+      await client.encryption.keyManager.clearOrUseOutboundGroupSession(roomId);
      expect(
          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
          false);

-      // rotate if devices in room change
+      // rotate if device is blocked
      sess =
          await client.encryption.keyManager.createOutboundGroupSession(roomId);
      client.userDeviceKeys['@alice:example.com'].deviceKeys['JLAFKJWSCS']
          .blocked = true;
-      await client.encryption.keyManager.clearOutboundGroupSession(roomId);
+      await client.encryption.keyManager.clearOrUseOutboundGroupSession(roomId);
      expect(
          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
          false);
@ -133,16 +135,61 @@ void main() {
      sess =
          await client.encryption.keyManager.createOutboundGroupSession(roomId);
      sess.creationTime = DateTime.now().subtract(Duration(days: 30));
-      await client.encryption.keyManager.clearOutboundGroupSession(roomId);
+      await client.encryption.keyManager.clearOrUseOutboundGroupSession(roomId);
      expect(
          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
          false);

+      // rotate if user leaves
+      sess =
+          await client.encryption.keyManager.createOutboundGroupSession(roomId);
+      final room = client.getRoomById(roomId);
+      final member = room.getState('m.room.member', '@alice:example.com');
+      member.content['membership'] = 'leave';
+      room.mJoinedMemberCount--;
+      await client.encryption.keyManager.clearOrUseOutboundGroupSession(roomId);
+      expect(
+          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
+          false);
+      member.content['membership'] = 'join';
+      room.mJoinedMemberCount++;
+
+      // do not rotate if new device is added
+      sess =
+          await client.encryption.keyManager.createOutboundGroupSession(roomId);
+      client.userDeviceKeys['@alice:example.com'].deviceKeys['NEWDEVICE'] =
+          DeviceKeys.fromJson({
+        'user_id': '@alice:example.com',
+        'device_id': 'NEWDEVICE',
+        'algorithms': ['m.olm.v1.curve25519-aes-sha2', 'm.megolm.v1.aes-sha2'],
+        'keys': {
+          'curve25519:JLAFKJWSCS':
+              '3C5BFWi2Y8MaVvjM8M22DBmh24PmgR0nPvJOIArzgyI',
+          'ed25519:JLAFKJWSCS': 'lEuiRJBit0IG6nUf5pUzWTUEsRVVe/HJkoKuEww9ULI'
+        },
+      }, client);
+      await client.encryption.keyManager.clearOrUseOutboundGroupSession(roomId);
+      expect(
+          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
+          true);
+
+      // do not rotate if new user is added
+      member.content['membership'] = 'leave';
+      room.mJoinedMemberCount--;
+      sess =
+          await client.encryption.keyManager.createOutboundGroupSession(roomId);
+      member.content['membership'] = 'join';
+      room.mJoinedMemberCount++;
+      await client.encryption.keyManager.clearOrUseOutboundGroupSession(roomId);
+      expect(
+          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
+          true);
+
      // force wipe
      sess =
          await client.encryption.keyManager.createOutboundGroupSession(roomId);
      await client.encryption.keyManager
-          .clearOutboundGroupSession(roomId, wipe: true);
+          .clearOrUseOutboundGroupSession(roomId, wipe: true);
      expect(
          client.encryption.keyManager.getOutboundGroupSession(roomId) != null,
          false);
@ -249,6 +296,30 @@ void main() {
      final senderKey = client.identityKey;
      final roomId = '!someroom:example.org';
      final sessionId = inbound.session_id();
+      final room = Room(id: roomId, client: client);
+      client.rooms.add(room);
+      // we build up an encrypted message so that we can test if it successfully decrypted afterwards
+      room.states['m.room.encrypted'] = Event(
+        senderId: '@test:example.com',
+        type: 'm.room.encrypted',
+        roomId: room.id,
+        room: room,
+        eventId: '12345',
+        originServerTs: DateTime.now(),
+        content: {
+          'algorithm': 'm.megolm.v1.aes-sha2',
+          'ciphertext': session.encrypt(json.encode({
+            'type': 'm.room.message',
+            'content': {'msgtype': 'm.text', 'body': 'foxies'},
+          })),
+          'device_id': client.deviceID,
+          'sender_key': client.identityKey,
+          'session_id': sessionId,
+        },
+        stateKey: '',
+        sortOrder: 42.0,
+      );
+      expect(room.lastEvent.type, 'm.room.encrypted');
      // set a payload...
      var sessionPayload = <String, dynamic>{
        'algorithm': 'm.megolm.v1.aes-sha2',
@ -379,6 +450,10 @@ void main() {
              .length,
          0);

+      // test that it decrypted the last event
+      expect(room.lastEvent.type, 'm.room.message');
+      expect(room.lastEvent.content['body'], 'foxies');
+
      inbound.free();
      session.free();
    });
--- a/test/encryption/key_verification_test.dart
+++ b/test/encryption/key_verification_test.dart
@ -54,7 +54,7 @@ EventUpdate getLastSentEvent(KeyVerification req) {
      'sender': req.client.userID,
    },
    eventType: type,
-    type: 'timeline',
+    type: EventUpdateType.timeline,
    roomID: req.room.id,
  );
 }
@ -85,7 +85,7 @@ void main() {
      client1 = await getClient();
      client2 = Client('othertestclient', httpClient: FakeMatrixApi());
      client2.database = client1.database;
-      await client2.checkServer('https://fakeServer.notExisting');
+      await client2.checkHomeserver('https://fakeServer.notExisting');
      client2.connect(
        newToken: 'abc',
        newUserID: '@othertest:fakeServer.notExisting',
@ -446,7 +446,7 @@ void main() {
          'sender': client2.userID,
        },
        eventType: 'm.key.verification.ready',
-        type: 'timeline',
+        type: EventUpdateType.timeline,
        roomID: req2.room.id,
      ));
      expect(req2.state, KeyVerificationState.error);
--- a/test/event_test.dart
+++ b/test/event_test.dart
@ -264,7 +264,7 @@ void main() {

    test('sendAgain', () async {
      var matrix = Client('testclient', httpClient: FakeMatrixApi());
-      await matrix.checkServer('https://fakeServer.notExisting');
+      await matrix.checkHomeserver('https://fakeServer.notExisting');
      await matrix.login(user: 'test', password: '1234');

      var event = Event.fromJson(
@ -280,7 +280,7 @@ void main() {

    test('requestKey', () async {
      var matrix = Client('testclient', httpClient: FakeMatrixApi());
-      await matrix.checkServer('https://fakeServer.notExisting');
+      await matrix.checkHomeserver('https://fakeServer.notExisting');
      await matrix.login(user: 'test', password: '1234');

      var event = Event.fromJson(
@ -990,7 +990,7 @@ void main() {
              THUMBNAIL_BUFF,
        }[url];
      };
-      await client.checkServer('https://fakeServer.notExisting');
+      await client.checkHomeserver('https://fakeServer.notExisting');
      final room = Room(id: '!localpart:server.abc', client: client);
      var event = Event.fromJson({
        'type': EventTypes.Message,
@ -1133,7 +1133,7 @@ void main() {
              FILE_BUFF,
        }[url];
      };
-      await client.checkServer('https://fakeServer.notExisting');
+      await client.checkHomeserver('https://fakeServer.notExisting');
      final room = Room(id: '!localpart:server.abc', client: await getClient());
      var event = Event.fromJson({
        'type': EventTypes.Message,
--- a/test/fake_client.dart
+++ b/test/fake_client.dart
@ -31,7 +31,7 @@ const pickledOlmAccount =
 Future<Client> getClient() async {
  final client = Client('testclient', httpClient: FakeMatrixApi());
  client.database = getDatabase();
-  await client.checkServer('https://fakeServer.notExisting');
+  await client.checkHomeserver('https://fakeServer.notExisting');
  client.connect(
    newToken: 'abcd',
    newUserID: '@test:fakeServer.notExisting',
--- a/test/markdown_test.dart
+++ b/test/markdown_test.dart
@ -73,6 +73,16 @@ void main() {
    test('latex', () {
      expect(markdown('meep \$\\frac{2}{3}\$'),
          'meep <span data-mx-maths="\\frac{2}{3}"><code>\\frac{2}{3}</code></span>');
+      expect(markdown('meep \$hmm *yay*\$'),
+          'meep <span data-mx-maths="hmm *yay*"><code>hmm *yay*</code></span>');
+      expect(markdown('you have \$somevar and \$someothervar'),
+          'you have \$somevar and \$someothervar');
+      expect(markdown('meep ||\$\\frac{2}{3}\$||'),
+          'meep <span data-mx-spoiler=""><span data-mx-maths="\\frac{2}{3}"><code>\\frac{2}{3}</code></span></span>');
+      expect(markdown('meep `\$\\frac{2}{3}\$`'),
+          'meep <code>\$\\frac{2}{3}\$</code>');
+      expect(markdown('hey\n\$\$beep\$\$\nmeow'),
+          '<p>hey</p>\n<div data-mx-maths="beep">\n<pre><code>beep</code></pre>\n</div>\n<p>meow</p>');
      expect(markdown('hey\n\$\$\nbeep\nboop\n\$\$\nmeow'),
          '<p>hey</p>\n<div data-mx-maths="beep\nboop">\n<pre><code>beep\nboop</code></pre>\n</div>\n<p>meow</p>');
    });
--- a/test/matrix_database_test.dart
+++ b/test/matrix_database_test.dart
@ -40,7 +40,7 @@ void main() {
    test('storeEventUpdate', () async {
      // store a simple update
      var update = EventUpdate(
-        type: 'timeline',
+        type: EventUpdateType.timeline,
        roomID: room.id,
        eventType: 'm.room.message',
        content: {
@ -58,7 +58,7 @@ void main() {

      // insert a transaction id
      update = EventUpdate(
-        type: 'timeline',
+        type: EventUpdateType.timeline,
        roomID: room.id,
        eventType: 'm.room.message',
        content: {
@ -75,7 +75,7 @@ void main() {
      event = await database.getEventById(clientId, 'transaction-1', room);
      expect(event.eventId, 'transaction-1');
      update = EventUpdate(
-        type: 'timeline',
+        type: EventUpdateType.timeline,
        roomID: room.id,
        eventType: 'm.room.message',
        content: {
@ -98,7 +98,7 @@ void main() {

      // insert a transaction id if the event id for it already exists
      update = EventUpdate(
-        type: 'timeline',
+        type: EventUpdateType.timeline,
        roomID: room.id,
        eventType: 'm.room.message',
        content: {
@ -115,7 +115,7 @@ void main() {
      event = await database.getEventById(clientId, '\$event-3', room);
      expect(event.eventId, '\$event-3');
      update = EventUpdate(
-        type: 'timeline',
+        type: EventUpdateType.timeline,
        roomID: room.id,
        eventType: 'm.room.message',
        content: {
@ -140,7 +140,7 @@ void main() {

      // insert transaction id and not update status
      update = EventUpdate(
-        type: 'timeline',
+        type: EventUpdateType.timeline,
        roomID: room.id,
        eventType: 'm.room.message',
        content: {
@ -157,7 +157,7 @@ void main() {
      event = await database.getEventById(clientId, '\$event-4', room);
      expect(event.eventId, '\$event-4');
      update = EventUpdate(
-        type: 'timeline',
+        type: EventUpdateType.timeline,
        roomID: room.id,
        eventType: 'm.room.message',
        content: {
--- a/test/mxc_uri_extension_test.dart
+++ b/test/mxc_uri_extension_test.dart
@ -27,7 +27,7 @@ void main() {
  group('MxContent', () {
    test('Formatting', () async {
      var client = Client('testclient', httpClient: FakeMatrixApi());
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      final mxc = 'mxc://exampleserver.abc/abcdefghijklmn';
      final content = Uri.parse(mxc);
      expect(content.isScheme('mxc'), true);
--- a/test/room_test.dart
+++ b/test/room_test.dart
@ -179,6 +179,31 @@ void main() {
      expect(room.timeCreated, room.lastEvent.originServerTs);
    });

+    test('multiple last event with same sort order', () {
+      room.states['m.room.encrypted'] = Event(
+          senderId: '@test:example.com',
+          type: 'm.room.encrypted',
+          roomId: room.id,
+          room: room,
+          eventId: '12345',
+          originServerTs: DateTime.now(),
+          content: {'msgtype': 'm.text', 'body': 'test'},
+          stateKey: '',
+          sortOrder: 42.0);
+      expect(room.lastEvent.type, 'm.room.encrypted');
+      room.states['m.room.messge'] = Event(
+          senderId: '@test:example.com',
+          type: 'm.room.messge',
+          roomId: room.id,
+          room: room,
+          eventId: '12345',
+          originServerTs: DateTime.now(),
+          content: {'msgtype': 'm.text', 'body': 'test'},
+          stateKey: '',
+          sortOrder: 42.0);
+      expect(room.lastEvent.type, 'm.room.encrypted');
+    });
+
    test('sendReadReceipt', () async {
      await room.sendReadReceipt('§1234:fakeServer.notExisting');
    });
--- a/test/timeline_test.dart
+++ b/test/timeline_test.dart
@ -49,10 +49,10 @@ void main() {
        });

    test('Create', () async {
-      await client.checkServer('https://fakeServer.notExisting');
+      await client.checkHomeserver('https://fakeServer.notExisting');

      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -65,7 +65,7 @@ void main() {
          },
          sortOrder: room.newSortOrder));
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -114,7 +114,7 @@ void main() {
      expect(timeline.events[0].receipts[0].user.id, '@alice:example.com');

      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.redaction',
          content: {
@ -149,7 +149,7 @@ void main() {
      expect(timeline.events[0].status, 1);

      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -174,7 +174,7 @@ void main() {

    test('Send message with error', () async {
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -221,7 +221,7 @@ void main() {
    test('Resend message', () async {
      timeline.events.clear();
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -278,7 +278,7 @@ void main() {
    test('sort errors on top', () async {
      timeline.events.clear();
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -291,7 +291,7 @@ void main() {
          },
          sortOrder: room.newSortOrder));
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -311,7 +311,7 @@ void main() {
    test('sending event to failed update', () async {
      timeline.events.clear();
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -327,7 +327,7 @@ void main() {
      expect(timeline.events[0].status, 0);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -347,7 +347,7 @@ void main() {
        () async {
      timeline.events.clear();
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -363,7 +363,7 @@ void main() {
      expect(timeline.events[0].status, 0);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -380,7 +380,7 @@ void main() {
      expect(timeline.events[0].status, 1);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -401,7 +401,7 @@ void main() {
        () async {
      timeline.events.clear();
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -420,7 +420,7 @@ void main() {
      expect(timeline.events[0].status, 0);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -439,7 +439,7 @@ void main() {
      expect(timeline.events[0].status, 2);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -461,7 +461,7 @@ void main() {
    test('sending an event 0 -> -1 -> 2', () async {
      timeline.events.clear();
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -477,7 +477,7 @@ void main() {
      expect(timeline.events[0].status, 0);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -493,7 +493,7 @@ void main() {
      expect(timeline.events[0].status, -1);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -513,7 +513,7 @@ void main() {
    test('sending an event 0 -> 2 -> -1', () async {
      timeline.events.clear();
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -529,7 +529,7 @@ void main() {
      expect(timeline.events[0].status, 0);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
@ -546,7 +546,7 @@ void main() {
      expect(timeline.events[0].status, 2);
      expect(timeline.events.length, 1);
      client.onEvent.add(EventUpdate(
-          type: 'timeline',
+          type: EventUpdateType.timeline,
          roomID: roomID,
          eventType: 'm.room.message',
          content: {
--- a/test/user_test.dart
+++ b/test/user_test.dart
@ -85,28 +85,28 @@ void main() {
          user3.calcDisplayname(mxidLocalPartFallback: false), 'Unknown user');
    });
    test('kick', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      await user1.kick();
    });
    test('ban', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      await user1.ban();
    });
    test('unban', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      await user1.unban();
    });
    test('setPower', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      await user1.setPower(50);
    });
    test('startDirectChat', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      await client.login(user: 'test', password: '1234');
      await user1.startDirectChat();
    });
    test('getPresence', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      await client.handleSync(SyncUpdate.fromJson({
        'presence': {
          'events': [
@ -121,15 +121,15 @@ void main() {
      expect(user1.presence.presence.presence, PresenceType.online);
    });
    test('canBan', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      expect(user1.canBan, false);
    });
    test('canKick', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      expect(user1.canKick, false);
    });
    test('canChangePowerLevel', () async {
-      await client.checkServer('https://fakeserver.notexisting');
+      await client.checkHomeserver('https://fakeserver.notexisting');
      expect(user1.canChangePowerLevel, false);
    });
    test('dispose client', () async {
--- a/test_driver/famedlysdk_test.dart
+++ b/test_driver/famedlysdk_test.dart
@ -24,7 +24,7 @@ void test() async {
    Logs.success('++++ Login Alice at ++++');
    testClientA = Client('TestClientA');
    testClientA.database = getDatabase();
-    await testClientA.checkServer(TestUser.homeserver);
+    await testClientA.checkHomeserver(TestUser.homeserver);
    await testClientA.login(
        user: TestUser.username, password: TestUser.password);
    assert(testClientA.encryptionEnabled);
@ -32,7 +32,7 @@ void test() async {
    Logs.success('++++ Login Bob ++++');
    testClientB = Client('TestClientB');
    testClientB.database = getDatabase();
-    await testClientB.checkServer(TestUser.homeserver);
+    await testClientB.checkHomeserver(TestUser.homeserver);
    await testClientB.login(
        user: TestUser.username2, password: TestUser.password);
    assert(testClientB.encryptionEnabled);
@ -222,7 +222,7 @@ void test() async {

    Logs.success('++++ Login Bob in another client ++++');
    var testClientC = Client('TestClientC', database: getDatabase());
-    await testClientC.checkServer(TestUser.homeserver);
+    await testClientC.checkHomeserver(TestUser.homeserver);
    await testClientC.login(
        user: TestUser.username2, password: TestUser.password);
    await Future.delayed(Duration(seconds: 3));