@unwanted/matrix-sdk-mini 34.12.0 → 36.0.0

package/lib/sync.js

@@ -170,10 +170,6 @@ export class SyncApi {
         }
         _this.opts.filter.setLazyLoadMembers(true);
       }
-      if (_this.opts.lazyLoadMembers) {
-        var _this$syncOpts$crypto;
-        (_this$syncOpts$crypto = _this.syncOpts.crypto) === null || _this$syncOpts$crypto === void 0 || _this$syncOpts$crypto.enableLazyLoading();
-      }
     }));
     _defineProperty(this, "storeClientOptions", /*#__PURE__*/_asyncToGenerator(function* () {
       try {
@@ -307,9 +303,10 @@ export class SyncApi {
       var localTimeoutMs = _this2.opts.pollTimeout + BUFFER_PERIOD_MS;
       var filterId = yield client.getOrCreateFilter(getFilterName(client.credentials.userId, "LEFT_ROOMS"), filter);
       var qps = {
-        timeout: 0,
+        "timeout": 0,
         // don't want to block since this is a single isolated req
-        filter: filterId
+        "filter": filterId,
+        "org.matrix.msc4222.use_state_after": true
       };
       var data = yield client.http.authedRequest(Method.Get, "/sync", qps, undefined, {
         localTimeoutMs
@@ -336,17 +333,16 @@ export class SyncApi {
             prev_batch: null,
             events: []
           };
-          var events = _this2.mapSyncEventsFormat(leaveObj.timeline, room);
-          var stateEvents = _this2.mapSyncEventsFormat(leaveObj.state, room);
-
           // set the back-pagination token. Do this *before* adding any
           // events so that clients can start back-paginating.
           room.getLiveTimeline().setPaginationToken(leaveObj.timeline.prev_batch, EventTimeline.BACKWARDS);
-          yield _this2.injectRoomEvents(room, stateEvents, events);
+          var {
+            timelineEvents
+          } = yield _this2.mapAndInjectRoomEvents(leaveObj);
           room.recalculate();
           client.store.storeRoom(room);
           client.emit(ClientEvent.Room, room);
-          _this2.processEventsForNotifs(room, events);
+          _this2.processEventsForNotifs(room, timelineEvents);
           return room;
         });
         return function (_x) {
@@ -424,7 +420,7 @@ export class SyncApi {
       // roll backwards to diverge old state. addEventsToTimeline
       // will overwrite the pagination token, so make sure it overwrites
       // it with the right thing.
-      this._peekRoom.addEventsToTimeline(messages.reverse(), true, this._peekRoom.getLiveTimeline(), response.messages.start);
+      this._peekRoom.addEventsToTimeline(messages.reverse(), true, true, this._peekRoom.getLiveTimeline(), response.messages.start);
       client.store.storeRoom(this._peekRoom);
       client.emit(ClientEvent.Room, this._peekRoom);
       this.peekPoll(this._peekRoom);
@@ -495,7 +491,9 @@ export class SyncApi {
         var events = res.chunk.filter(function (e) {
           return e.room_id === peekRoom.roomId && e.event_id;
         }).map(_this3.client.getEventMapper());
-        yield peekRoom.addLiveEvents(events);
+        yield peekRoom.addLiveEvents(events, {
+          addToState: true
+        });
         _this3.peekPoll(peekRoom, res.end);
       });
       return function (_x2) {
@@ -750,11 +748,6 @@ export class SyncApi {
           nextSyncToken: data.next_batch,
           catchingUp: _this7.catchingUp
         };
-        if (_this7.syncOpts.crypto) {
-          // tell the crypto module we're about to process a sync
-          // response
-          yield _this7.syncOpts.crypto.onSyncWillProcess(syncEventData);
-        }
         try {
           yield _this7.processSyncResponse(syncEventData, data);
         } catch (e) {
@@ -779,24 +772,9 @@ export class SyncApi {
           syncOptions.hasSyncedBefore = true;
         }
 
-        // tell the crypto module to do its processing. It may block (to do a
-        // /keys/changes request).
-        if (_this7.syncOpts.cryptoCallbacks) {
-          yield _this7.syncOpts.cryptoCallbacks.onSyncCompleted(syncEventData);
-        }
-
         // keep emitting SYNCING -> SYNCING for clients who want to do bulk updates
         _this7.updateSyncState(SyncState.Syncing, syncEventData);
         if (_this7.client.store.wantsSave()) {
-          // We always save the device list (if it's dirty) before saving the sync data:
-          // this means we know the saved device list data is at least as fresh as the
-          // stored sync data which means we don't have to worry that we may have missed
-          // device changes. We can also skip the delay since we're not calling this very
-          // frequently (and we don't really want to delay the sync for it).
-          if (_this7.syncOpts.crypto) {
-            yield _this7.syncOpts.crypto.saveDeviceList(0);
-          }
-
           // tell databases that everything is now in a consistent state and can be saved.
           yield _this7.client.store.save();
         }
@@ -842,7 +820,8 @@ export class SyncApi {
     }
     var qps = {
       filter,
-      timeout
+      timeout,
+      "org.matrix.msc4222.use_state_after": true
     };
     if (this.opts.disablePresence) {
       qps.set_presence = SetPresence.Offline;
@@ -931,7 +910,7 @@ export class SyncApi {
   processSyncResponse(syncEventData, data) {
     var _this9 = this;
     return _asyncToGenerator(function* () {
-      var _data$presence, _data$account_data, _this9$syncOpts$crypt, _data$device_unused_f;
+      var _data$presence, _data$account_data;
       var client = _this9.client;
 
       // data looks like:
@@ -1020,9 +999,6 @@ export class SyncApi {
       // handle to-device events
       if (data.to_device && Array.isArray(data.to_device.events) && data.to_device.events.length > 0) {
         var toDeviceMessages = data.to_device.events.filter(noUnsafeEventProps);
-        if (_this9.syncOpts.cryptoCallbacks) {
-          toDeviceMessages = yield _this9.syncOpts.cryptoCallbacks.preprocessToDeviceMessages(toDeviceMessages);
-        }
         var cancelledKeyVerificationTxns = [];
         toDeviceMessages.map(client.getEventMapper({
           toDevice: true
@@ -1089,23 +1065,9 @@ export class SyncApi {
       // Handle invites
       yield promiseMapSeries(inviteRooms, /*#__PURE__*/function () {
         var _ref7 = _asyncToGenerator(function* (inviteObj) {
-          var _room$currentState$ge;
           var room = inviteObj.room;
           var stateEvents = _this9.mapSyncEventsFormat(inviteObj.invite_state, room);
-          yield _this9.injectRoomEvents(room, stateEvents);
-          var inviter = (_room$currentState$ge = room.currentState.getStateEvents(EventType.RoomMember, client.getUserId())) === null || _room$currentState$ge === void 0 ? void 0 : _room$currentState$ge.getSender();
-          var crypto = client.crypto;
-          if (crypto) {
-            var parkedHistory = yield crypto.cryptoStore.takeParkedSharedHistory(room.roomId);
-            for (var parked of parkedHistory) {
-              if (parked.senderId === inviter) {
-                yield crypto.olmDevice.addInboundGroupSession(room.roomId, parked.senderKey, parked.forwardingCurve25519KeyChain, parked.sessionId, parked.sessionKey, parked.keysClaimed, true, {
-                  sharedHistory: true,
-                  untrusted: true
-                });
-              }
-            }
-          }
+          yield _this9.injectRoomEvents(room, stateEvents, undefined);
           if (inviteObj.isBrandNewRoom) {
             room.recalculate();
             client.store.storeRoom(room);
@@ -1129,14 +1091,21 @@ export class SyncApi {
           var _joinObj$UNREAD_THREA;
           var room = joinObj.room;
           var stateEvents = _this9.mapSyncEventsFormat(joinObj.state, room);
+          var stateAfterEvents = _this9.mapSyncEventsFormat(joinObj["org.matrix.msc4222.state_after"], room);
           // Prevent events from being decrypted ahead of time
           // this helps large account to speed up faster
           // room::decryptCriticalEvent is in charge of decrypting all the events
           // required for a client to function properly
-          var events = _this9.mapSyncEventsFormat(joinObj.timeline, room, false);
+          var timelineEvents = _this9.mapSyncEventsFormat(joinObj.timeline, room, false);
           var ephemeralEvents = _this9.mapSyncEventsFormat(joinObj.ephemeral);
           var accountDataEvents = _this9.mapSyncEventsFormat(joinObj.account_data);
-          var encrypted = _this9.isRoomEncrypted(room, stateEvents, events);
+
+          // If state_after is present, this is the events that form the state at the end of the timeline block and
+          // regular timeline events do *not* count towards state. If it's not present, then the state is formed by
+          // the state events plus the timeline events. Note mapSyncEventsFormat returns an empty array if the field
+          // is absent so we explicitly check the field on the original object.
+          var eventsFormingFinalState = joinObj["org.matrix.msc4222.state_after"] ? stateAfterEvents : stateEvents.concat(timelineEvents);
+          var encrypted = _this9.isRoomEncrypted(room, eventsFormingFinalState);
           // We store the server-provided value first so it's correct when any of the events fire.
           if (joinObj.unread_notifications) {
             /**
@@ -1207,8 +1176,8 @@ export class SyncApi {
             // which we'll try to paginate but not get any new events (which
             // will stop us linking the empty timeline into the chain).
             //
-            for (var i = events.length - 1; i >= 0; i--) {
-              var eventId = events[i].getId();
+            for (var i = timelineEvents.length - 1; i >= 0; i--) {
+              var eventId = timelineEvents[i].getId();
               if (room.getTimelineForEvent(eventId)) {
                 debuglog("Already have event ".concat(eventId, " in limited sync - not resetting"));
                 limited = false;
@@ -1216,7 +1185,7 @@ export class SyncApi {
                 // we might still be missing some of the events before i;
                 // we don't want to be adding them to the end of the
                 // timeline because that would put them out of order.
-                events.splice(0, i);
+                timelineEvents.splice(0, i);
 
                 // XXX: there's a problem here if the skipped part of the
                 // timeline modifies the state set in stateEvents, because
@@ -1238,20 +1207,12 @@ export class SyncApi {
               client.resetNotifTimelineSet();
             }
           }
-
-          // process any crypto events *before* emitting the RoomStateEvent events. This
-          // avoids a race condition if the application tries to send a message after the
-          // state event is processed, but before crypto is enabled, which then causes the
-          // crypto layer to complain.
-          if (_this9.syncOpts.cryptoCallbacks) {
-            for (var e of stateEvents.concat(events)) {
-              if (e.isState() && e.getType() === EventType.RoomEncryption && e.getStateKey() === "") {
-                yield _this9.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);
-              }
-            }
-          }
           try {
-            yield _this9.injectRoomEvents(room, stateEvents, events, syncEventData.fromCache);
+            if ("org.matrix.msc4222.state_after" in joinObj) {
+              yield _this9.injectRoomEvents(room, undefined, stateAfterEvents, timelineEvents, syncEventData.fromCache);
+            } else {
+              yield _this9.injectRoomEvents(room, stateEvents, undefined, timelineEvents, syncEventData.fromCache);
+            }
           } catch (e) {
             logger.error("Failed to process events on room ".concat(room.roomId, ":"), e);
           }
@@ -1273,17 +1234,12 @@ export class SyncApi {
             client.store.storeRoom(room);
             client.emit(ClientEvent.Room, room);
           }
-          _this9.processEventsForNotifs(room, events);
+          _this9.processEventsForNotifs(room, timelineEvents);
           var emitEvent = e => client.emit(ClientEvent.Event, e);
           stateEvents.forEach(emitEvent);
-          events.forEach(emitEvent);
+          timelineEvents.forEach(emitEvent);
           ephemeralEvents.forEach(emitEvent);
           accountDataEvents.forEach(emitEvent);
-
-          // Decrypt only the last message in all rooms to make sure we can generate a preview
-          // And decrypt all events after the recorded read receipt to ensure an accurate
-          // notification count
-          room.decryptCriticalEvents();
         });
         return function (_x4) {
           return _ref8.apply(this, arguments);
@@ -1294,21 +1250,26 @@ export class SyncApi {
       yield promiseMapSeries(leaveRooms, /*#__PURE__*/function () {
         var _ref9 = _asyncToGenerator(function* (leaveObj) {
           var room = leaveObj.room;
-          var stateEvents = _this9.mapSyncEventsFormat(leaveObj.state, room);
-          var events = _this9.mapSyncEventsFormat(leaveObj.timeline, room);
+          var {
+            timelineEvents,
+            stateEvents,
+            stateAfterEvents
+          } = yield _this9.mapAndInjectRoomEvents(leaveObj);
           var accountDataEvents = _this9.mapSyncEventsFormat(leaveObj.account_data);
-          yield _this9.injectRoomEvents(room, stateEvents, events);
           room.addAccountData(accountDataEvents);
           room.recalculate();
           if (leaveObj.isBrandNewRoom) {
             client.store.storeRoom(room);
             client.emit(ClientEvent.Room, room);
           }
-          _this9.processEventsForNotifs(room, events);
-          stateEvents.forEach(function (e) {
+          _this9.processEventsForNotifs(room, timelineEvents);
+          stateEvents === null || stateEvents === void 0 || stateEvents.forEach(function (e) {
+            client.emit(ClientEvent.Event, e);
+          });
+          stateAfterEvents === null || stateAfterEvents === void 0 || stateAfterEvents.forEach(function (e) {
             client.emit(ClientEvent.Event, e);
           });
-          events.forEach(function (e) {
+          timelineEvents.forEach(function (e) {
             client.emit(ClientEvent.Event, e);
           });
           accountDataEvents.forEach(function (e) {
@@ -1325,7 +1286,7 @@ export class SyncApi {
         var _ref10 = _asyncToGenerator(function* (knockObj) {
           var room = knockObj.room;
           var stateEvents = _this9.mapSyncEventsFormat(knockObj.knock_state, room);
-          yield _this9.injectRoomEvents(room, stateEvents);
+          yield _this9.injectRoomEvents(room, stateEvents, undefined);
           if (knockObj.isBrandNewRoom) {
             room.recalculate();
             client.store.storeRoom(room);
@@ -1354,23 +1315,11 @@ export class SyncApi {
         });
         _this9.notifEvents.forEach(function (event) {
           var _client$getNotifTimel;
-          (_client$getNotifTimel = client.getNotifTimelineSet()) === null || _client$getNotifTimel === void 0 || _client$getNotifTimel.addLiveEvent(event);
+          (_client$getNotifTimel = client.getNotifTimelineSet()) === null || _client$getNotifTimel === void 0 || _client$getNotifTimel.addLiveEvent(event, {
+            addToState: true
+          });
         });
       }
-
-      // Handle device list updates
-      if (data.device_lists) {
-        if (_this9.syncOpts.cryptoCallbacks) {
-          yield _this9.syncOpts.cryptoCallbacks.processDeviceLists(data.device_lists);
-        } else {
-          // FIXME if we *don't* have a crypto module, we still need to
-          // invalidate the device lists. But that would require a
-          // substantial bit of rework :/.
-        }
-      }
-
-      // Handle one_time_keys_count and unused fallback keys
-      yield (_this9$syncOpts$crypt = _this9.syncOpts.cryptoCallbacks) === null || _this9$syncOpts$crypt === void 0 ? void 0 : _this9$syncOpts$crypt.processKeyCounts(data.device_one_time_keys_count, (_data$device_unused_f = data.device_unused_fallback_key_types) !== null && _data$device_unused_f !== void 0 ? _data$device_unused_f : data["org.matrix.msc2732.device_unused_fallback_key_types"]);
     })();
   }
 
@@ -1542,23 +1491,51 @@ export class SyncApi {
 
   // When processing the sync response we cannot rely on Room.hasEncryptionStateEvent we actually
   // inject the events into the room object, so we have to inspect the events themselves.
-  isRoomEncrypted(room, stateEventList, timelineEventList) {
-    return room.hasEncryptionStateEvent() || !!this.findEncryptionEvent(stateEventList) || !!this.findEncryptionEvent(timelineEventList);
+  isRoomEncrypted(room, eventsFormingFinalState) {
+    return room.hasEncryptionStateEvent() || !!this.findEncryptionEvent(eventsFormingFinalState);
+  }
+  mapAndInjectRoomEvents(wrappedRoom) {
+    var _this10 = this;
+    return _asyncToGenerator(function* () {
+      var stateEvents = _this10.mapSyncEventsFormat(wrappedRoom.state, wrappedRoom.room);
+      var stateAfterEvents = _this10.mapSyncEventsFormat(wrappedRoom["org.matrix.msc4222.state_after"], wrappedRoom.room);
+      var timelineEvents = _this10.mapSyncEventsFormat(wrappedRoom.timeline, wrappedRoom.room);
+      if ("org.matrix.msc4222.state_after" in wrappedRoom) {
+        yield _this10.injectRoomEvents(wrappedRoom.room, undefined, stateAfterEvents, timelineEvents);
+      } else {
+        yield _this10.injectRoomEvents(wrappedRoom.room, stateEvents, undefined, timelineEvents);
+      }
+      return {
+        timelineEvents,
+        stateEvents,
+        stateAfterEvents
+      };
+    })();
   }
 
   /**
    * Injects events into a room's model.
    * @param stateEventList - A list of state events. This is the state
    * at the *START* of the timeline list if it is supplied.
+   * @param stateAfterEventList - A list of state events. This is the state
+   * at the *END* of the timeline list if it is supplied.
    * @param timelineEventList - A list of timeline events, including threaded. Lower index
    * is earlier in time. Higher index is later.
    * @param fromCache - whether the sync response came from cache
+   *
+   * No more than one of stateEventList and stateAfterEventList must be supplied. If
+   * stateEventList is supplied, the events in timelineEventList are added to the state
+   * after stateEventList. If stateAfterEventList is supplied, the events in timelineEventList
+   * are not added to the state.
    */
-  injectRoomEvents(room, stateEventList, timelineEventList) {
+
+  injectRoomEvents(room, stateEventList, stateAfterEventList, timelineEventList) {
     var _arguments = arguments,
-      _this10 = this;
+      _this11 = this;
     return _asyncToGenerator(function* () {
-      var fromCache = _arguments.length > 3 && _arguments[3] !== undefined ? _arguments[3] : false;
+      var fromCache = _arguments.length > 4 && _arguments[4] !== undefined ? _arguments[4] : false;
+      var eitherStateEventList = stateAfterEventList !== null && stateAfterEventList !== void 0 ? stateAfterEventList : stateEventList;
+
       // If there are no events in the timeline yet, initialise it with
       // the given state events
       var liveTimeline = room.getLiveTimeline();
@@ -1572,14 +1549,15 @@ export class SyncApi {
         // push actions cache elsewhere so we can freeze MatrixEvents, or otherwise
         // find some solution where MatrixEvents are immutable but allow for a cache
         // field.
-        for (var ev of stateEventList) {
-          _this10.client.getPushActionsForEvent(ev);
+
+        for (var ev of eitherStateEventList) {
+          _this11.client.getPushActionsForEvent(ev);
         }
-        liveTimeline.initialiseState(stateEventList, {
+        liveTimeline.initialiseState(eitherStateEventList, {
           timelineWasEmpty
         });
       }
-      _this10.resolveInvites(room);
+      _this11.resolveInvites(room);
 
       // recalculate the room name at this point as adding events to the timeline
       // may make notifications appear which should have the right name.
@@ -1606,19 +1584,20 @@ export class SyncApi {
         // XXX: As above, don't do this...
         //room.addLiveEvents(stateEventList || []);
         // Do this instead...
-        room.oldState.setStateEvents(stateEventList || []);
-        room.currentState.setStateEvents(stateEventList || []);
+        room.oldState.setStateEvents(eitherStateEventList);
+        room.currentState.setStateEvents(eitherStateEventList);
       }
 
-      // Execute the timeline events. This will continue to diverge the current state
-      // if the timeline has any state events in it.
+      // Execute the timeline events. If addToState is true the timeline has any state
+      // events in it, this will continue to diverge the current state.
       // This also needs to be done before running push rules on the events as they need
       // to be decorated with sender etc.
       yield room.addLiveEvents(timelineEventList || [], {
         fromCache,
-        timelineWasEmpty
+        timelineWasEmpty,
+        addToState: stateAfterEventList === undefined
       });
-      _this10.client.processBeaconEvents(room, timelineEventList);
+      _this11.client.processBeaconEvents(room, timelineEventList);
     })();
   }