fix: Add the closure expectation to the event

Call _reconnectionPolicy.onSuccess when negotiations are done. Never
call onFailure directly; only ever call handleError.

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: papatutuwawa

README.md

@@ -3,13 +3,13 @@
 moxxmpp is a XMPP library written purely in Dart for usage in Moxxy.
 
 ## Packages
-### moxxmpp
+### [moxxmpp](./packages/moxxmpp)
 
 This package contains the actual XMPP code that is platform-independent.
 
-### moxxmpp_socket
+### [moxxmpp_socket_tcp](./packages/moxxmpp_socket_tcp)
 
-`moxxmpp_socket` contains the implementation of the `BaseSocketWrapper` class that
+`moxxmpp_socket_tcp` contains the implementation of the `BaseSocketWrapper` class that
 implements the RFC6120 connection algorithm and XEP-0368 direct TLS connections,
 if a DNS implementation is given, and supports StartTLS.
 
@@ -25,3 +25,9 @@ the development shell provided by the NixOS Flake, ensure that `ANDROID_HOME` an
 ## License
 
 See `./LICENSE`.
+
+## Support
+
+If you like what I do and you want to support me, feel free to donate to me on Ko-Fi.
+
+[<img src="https://codeberg.org/moxxy/moxxyv2/raw/branch/master/assets/repo/kofi.png" height="36" style="height: 36px; border: 0px;"></img>](https://ko-fi.com/papatutuwawa)

packages/moxxmpp/README.md

@@ -2,6 +2,22 @@
 
 A pure-Dart XMPP library written for Moxxy.
 
+## Usage
+
+Include the following as a dependency in your pubspec file:
+
+```
+ moxxmpp:
+    hosted: https://git.polynom.me/api/packages/Moxxy/pub
+    version: 0.1.6+1
+```
+
 ## License
 
 See `./LICENSE`.
+
+## Support
+
+If you like what I do and you want to support me, feel free to donate to me on Ko-Fi.
+
+[<img src="https://codeberg.org/moxxy/moxxyv2/raw/branch/master/assets/repo/kofi.png" height="36" style="height: 36px; border: 0px;"></img>](https://ko-fi.com/papatutuwawa)

packages/moxxmpp/lib/moxxmpp.dart

@@ -29,6 +29,7 @@ export 'package:moxxmpp/src/rfcs/rfc_2782.dart';
 export 'package:moxxmpp/src/rfcs/rfc_4790.dart';
 export 'package:moxxmpp/src/roster/errors.dart';
 export 'package:moxxmpp/src/roster/roster.dart';
+export 'package:moxxmpp/src/roster/state.dart';
 export 'package:moxxmpp/src/settings.dart';
 export 'package:moxxmpp/src/socket.dart';
 export 'package:moxxmpp/src/stanza.dart';
@@ -75,7 +76,9 @@ export 'package:moxxmpp/src/xeps/xep_0384/xep_0384.dart';
 export 'package:moxxmpp/src/xeps/xep_0385.dart';
 export 'package:moxxmpp/src/xeps/xep_0414.dart';
 export 'package:moxxmpp/src/xeps/xep_0424.dart';
+export 'package:moxxmpp/src/xeps/xep_0444.dart';
 export 'package:moxxmpp/src/xeps/xep_0446.dart';
 export 'package:moxxmpp/src/xeps/xep_0447.dart';
 export 'package:moxxmpp/src/xeps/xep_0448.dart';
+export 'package:moxxmpp/src/xeps/xep_0449.dart';
 export 'package:moxxmpp/src/xeps/xep_0461.dart';

packages/moxxmpp/lib/src/connection.dart

@@ -1,6 +1,7 @@
 import 'dart:async';
 import 'package:logging/logging.dart';
 import 'package:meta/meta.dart';
+import 'package:moxlib/moxlib.dart';
 import 'package:moxxmpp/src/buffer.dart';
 import 'package:moxxmpp/src/errors.dart';
 import 'package:moxxmpp/src/events.dart';
@@ -28,22 +29,35 @@ import 'package:moxxmpp/src/xeps/xep_0352.dart';
 import 'package:synchronized/synchronized.dart';
 import 'package:uuid/uuid.dart';
 
+/// The states the XmppConnection can be in
 enum XmppConnectionState {
+  /// The XmppConnection instance is not connected to the server. This is either the
+  /// case before connecting or after disconnecting.
   notConnected,
+
+  /// We are currently trying to connect to the server.
   connecting,
+
+  /// We are currently connected to the server.
   connected,
+
+  /// We have received an unrecoverable error and the server killed the connection
   error
 }
 
+/// Metadata for [XmppConnection.sendStanza].
 enum StanzaFromType {
-  // Add the full JID to the stanza as the from attribute
+  /// Add the full JID to the stanza as the from attribute
   full,
-  // Add the bare JID to the stanza as the from attribute
+
+  /// Add the bare JID to the stanza as the from attribute
   bare,
-  // Add no JID as the from attribute
-  none
+
+  /// Add no JID as the from attribute
+  none,
 }
 
+/// Nonza describing the XMPP stream header.
 class StreamHeaderNonza extends XMLNode {
   StreamHeaderNonza(String serverDomain) : super(
       tag: 'stream:stream',
@@ -58,6 +72,7 @@ class StreamHeaderNonza extends XMLNode {
     );
 }
 
+/// The result of an awaited connection.
 class XmppConnectionResult {
   const XmppConnectionResult(
     this.success,
@@ -66,16 +81,39 @@ class XmppConnectionResult {
     }
   );
 
+  /// True if the connection was successful. False if it failed for any reason.
   final bool success;
+
   // If a connection attempt fails, i.e. success is false, then this indicates the
   // reason the connection failed.
   final XmppError? error;
 }
 
+/// A surrogate key for awaiting stanzas.
+@immutable
+class _StanzaAwaitableData {
+  const _StanzaAwaitableData(this.sentTo, this.id);
+
+  /// The JID the original stanza was sent to. We expect the result to come from the
+  /// same JID.
+  final String sentTo;
+
+  /// The ID of the original stanza. We expect the result to have the same ID.
+  final String id;
+
+  @override
+  int get hashCode => sentTo.hashCode ^ id.hashCode;
+
+  @override
+  bool operator==(Object other) {
+    return other is _StanzaAwaitableData &&
+           other.sentTo == sentTo &&
+           other.id == id;
+  }
+}
+
+/// This class is a connection to the server.
 class XmppConnection {
-  /// [_socket] is for debugging purposes.
-  /// [connectionPingDuration] is the duration after which a ping will be sent to keep
-  /// the connection open. Defaults to 15 minutes.
   XmppConnection(
     ReconnectionPolicy reconnectionPolicy,
     this._socket,
@@ -83,25 +121,7 @@ class XmppConnection {
       this.connectionPingDuration = const Duration(minutes: 3),
       this.connectingTimeout = const Duration(minutes: 2),
     }
-  ) :
-    _connectionState = XmppConnectionState.notConnected,
-    _routingState = RoutingState.preConnection,
-    _eventStreamController = StreamController.broadcast(),
-    _resource = '',
-    _streamBuffer = XmlStreamBuffer(),
-    _uuid = const Uuid(),
-    _awaitingResponse = {},
-    _awaitingResponseLock = Lock(),
-    _xmppManagers = {},
-    _incomingStanzaHandlers = List.empty(growable: true),
-    _outgoingPreStanzaHandlers = List.empty(growable: true),
-    _outgoingPostStanzaHandlers = List.empty(growable: true),
-    _reconnectionPolicy = reconnectionPolicy,
-    _featureNegotiators = {},
-    _streamFeatures = List.empty(growable: true),
-    _negotiationLock = Lock(),
-    _isAuthenticated = false,
-    _log = Logger('XmppConnection') {
+  ) : _reconnectionPolicy = reconnectionPolicy {
       // Allow the reconnection policy to perform reconnections by itself
       _reconnectionPolicy.register(
         _attemptReconnection,
@@ -115,69 +135,101 @@ class XmppConnection {
   }
 
 
-  /// Connection properties
-  ///
-  /// The state that the connection currently is in
-  XmppConnectionState _connectionState;
+  /// The state that the connection is currently in
+  XmppConnectionState _connectionState = XmppConnectionState.notConnected;
+
   /// The socket that we are using for the connection and its data stream
   final BaseSocketWrapper _socket;
+
+  /// The data stream of the socket
   late final Stream<String> _socketStream;
-  /// Account settings
+
+
+  /// Connection settings
   late ConnectionSettings _connectionSettings;
+
   /// A policy on how to reconnect 
   final ReconnectionPolicy _reconnectionPolicy;
-  /// A list of stanzas we are tracking with its corresponding critical section
-  final Map<String, Completer<XMLNode>> _awaitingResponse;
-  final Lock _awaitingResponseLock;
+
+  /// A list of stanzas we are tracking with its corresponding critical section lock
+  final Map<_StanzaAwaitableData, Completer<XMLNode>> _awaitingResponse = {};
+  final Lock _awaitingResponseLock = Lock();
   
-  /// Helpers
-  ///
-  final List<StanzaHandler> _incomingStanzaHandlers;
-  final List<StanzaHandler> _outgoingPreStanzaHandlers;
-  final List<StanzaHandler> _outgoingPostStanzaHandlers;
-  final StreamController<XmppEvent> _eventStreamController;
-  final Map<String, XmppManagerBase> _xmppManagers;
+  /// Sorted list of handlers that we call or incoming and outgoing stanzas
+  final List<StanzaHandler> _incomingStanzaHandlers = List.empty(growable: true);
+  final List<StanzaHandler> _incomingPreStanzaHandlers = List.empty(growable: true);
+  final List<StanzaHandler> _outgoingPreStanzaHandlers = List.empty(growable: true);
+  final List<StanzaHandler> _outgoingPostStanzaHandlers = List.empty(growable: true);
+  final StreamController<XmppEvent> _eventStreamController = StreamController.broadcast();
+  final Map<String, XmppManagerBase> _xmppManagers = {};
   
-  /// Stream properties
-  ///
   /// Disco info we got after binding a resource (xmlns)
   final List<String> _serverFeatures = List.empty(growable: true);
+
   /// The buffer object to keep split up stanzas together
-  final XmlStreamBuffer _streamBuffer;
+  final XmlStreamBuffer _streamBuffer = XmlStreamBuffer();
+
   /// UUID object to generate stanza and origin IDs
-  final Uuid _uuid;
+  final Uuid _uuid = const Uuid();
+
   /// The time between sending a ping to keep the connection open
   // TODO(Unknown): Only start the timer if we did not send a stanza after n seconds
   final Duration connectionPingDuration;
+
   /// The time that we may spent in the "connecting" state
   final Duration connectingTimeout;
+
   /// The current state of the connection handling state machine.
-  RoutingState _routingState;
+  RoutingState _routingState = RoutingState.preConnection;
+
   /// The currently bound resource or '' if none has been bound yet.
-  String _resource;
+  String _resource = '';
+
   /// True if we are authenticated. False if not.
-  bool _isAuthenticated;
+  bool _isAuthenticated = false;
+
   /// Timer for the keep-alive ping.
   Timer? _connectionPingTimer;
+
   /// Timer for the connecting timeout
   Timer? _connectingTimeoutTimer;
+
   /// Completers for certain actions
   // ignore: use_late_for_private_fields_and_variables
   Completer<XmppConnectionResult>? _connectionCompleter;
-  /// Controls whether an XmppSocketClosureEvent triggers a reconnection.
-  bool _socketClosureTriggersReconnect = true;
 
   /// Negotiators
-  final Map<String, XmppFeatureNegotiatorBase> _featureNegotiators;
+  final Map<String, XmppFeatureNegotiatorBase> _featureNegotiators = {};
   XmppFeatureNegotiatorBase? _currentNegotiator;
-  final List<XMLNode> _streamFeatures;
+  final List<XMLNode> _streamFeatures = List.empty(growable: true);
   /// Prevent data from being passed to _currentNegotiator.negotiator while the negotiator
   /// is still running.
-  final Lock _negotiationLock;
+  final Lock _negotiationLock = Lock();
   
-  /// Misc
-  final Logger _log;
+  /// The logger for the class
+  final Logger _log = Logger('XmppConnection');
 
+  /// A value indicating whether a connection attempt is currently running or not
+  bool _isConnectionRunning = false;
+  final Lock _connectionRunningLock = Lock();
+
+  /// Enters the critical section for accessing [XmppConnection._isConnectionRunning]
+  /// and does the following:
+  /// - if _isConnectionRunning is false, set it to true and return false.
+  /// - if _isConnectionRunning is true, return true.
+  Future<bool> _testAndSetIsConnectionRunning() async => _connectionRunningLock.synchronized(() {
+    if (!_isConnectionRunning) {
+      _isConnectionRunning = true;
+      return false;
+    }
+
+    return true;
+  });
+
+  /// Enters the critical section for accessing [XmppConnection._isConnectionRunning]
+  /// and sets it to false.
+  Future<void> _resetIsConnectionRunning() async => _connectionRunningLock.synchronized(() => _isConnectionRunning = false);
+  
   ReconnectionPolicy get reconnectionPolicy => _reconnectionPolicy;
   
   List<String> get serverFeatures => _serverFeatures;
@@ -223,11 +275,13 @@ class XmppConnection {
     }
 
     _incomingStanzaHandlers.addAll(manager.getIncomingStanzaHandlers());
+    _incomingPreStanzaHandlers.addAll(manager.getIncomingPreStanzaHandlers());
     _outgoingPreStanzaHandlers.addAll(manager.getOutgoingPreStanzaHandlers());
     _outgoingPostStanzaHandlers.addAll(manager.getOutgoingPostStanzaHandlers());
     
     if (sortHandlers) {
       _incomingStanzaHandlers.sort(stanzaHandlerSortComparator);
+      _incomingPreStanzaHandlers.sort(stanzaHandlerSortComparator);
       _outgoingPreStanzaHandlers.sort(stanzaHandlerSortComparator);
       _outgoingPostStanzaHandlers.sort(stanzaHandlerSortComparator);
     }
@@ -331,6 +385,11 @@ class XmppConnection {
 
   /// Attempts to reconnect to the server by following an exponential backoff.
   Future<void> _attemptReconnection() async {
+    if (await _testAndSetIsConnectionRunning()) {
+      _log.warning('_attemptReconnection is called but connection attempt is already running. Ignoring...');
+      return;
+    }
+
     _log.finest('_attemptReconnection: Setting state to notConnected');
     await _setConnectionState(XmppConnectionState.notConnected);
     _log.finest('_attemptReconnection: Done');
@@ -374,9 +433,9 @@ class XmppConnection {
     if (event is XmppSocketErrorEvent) {
       await handleError(SocketError(event));
     } else if (event is XmppSocketClosureEvent) {
-      if (_socketClosureTriggersReconnect) {
-        _log.fine('Received XmppSocketClosureEvent. Reconnecting...');
-        await _reconnectionPolicy.onFailure();
+      if (!event.expected) {
+        _log.fine('Received unexpected XmppSocketClosureEvent. Reconnecting...');
+        await handleError(SocketError(XmppSocketErrorEvent(event)));
       } else {
         _log.fine('Received XmppSocketClosureEvent. No reconnection attempt since _socketClosureTriggersReconnect is false...');
       }
@@ -424,9 +483,10 @@ class XmppConnection {
   /// none.
   // TODO(Unknown): if addId = false, the function crashes.
   Future<XMLNode> sendStanza(Stanza stanza, { StanzaFromType addFrom = StanzaFromType.full, bool addId = true, bool awaitable = true, bool encrypted = false }) async {
-    var stanza_ = stanza;
-    
+    assert(implies(addId == false && stanza.id == null, !awaitable), 'Cannot await a stanza with no id');
+
     // Add extra data in case it was not set
+    var stanza_ = stanza;
     if (addId && (stanza_.id == null || stanza_.id == '')) {
       stanza_ = stanza.copyWith(id: generateId());
     }
@@ -444,8 +504,6 @@ class XmppConnection {
       }
     }
 
-    final id = stanza_.id!;
-
     _log.fine('Running pre stanza handlers..');
     final data = await _runOutgoingPreStanzaHandlers(
       stanza_,
@@ -483,42 +541,45 @@ class XmppConnection {
     final stanzaString = data.stanza.toXml();
 
     // ignore: cascade_invocations
-    _log.fine('Attempting to acquire lock for $id...');
+    _log.fine('Attempting to acquire lock for ${data.stanza.id}...');
     // TODO(PapaTutuWawa): Handle this much more graceful
     var future = Future.value(XMLNode(tag: 'not-used'));
     await _awaitingResponseLock.synchronized(() async {
-        _log.fine('Lock acquired for $id');
-        if (awaitable) {
-          _awaitingResponse[id] = Completer();
-        }
+      _log.fine('Lock acquired for ${data.stanza.id}');
 
-        // This uses the StreamManager to behave like a send queue
-        if (await _canSendData()) {
-          _socket.write(stanzaString);
+      _StanzaAwaitableData? key;
+      if (awaitable) {
+        key = _StanzaAwaitableData(data.stanza.to!, data.stanza.id!);
+        _awaitingResponse[key] = Completer();
+      }
 
-          // Try to ack every stanza
-          // NOTE: Here we have send an Ack request nonza. This is now done by StreamManagementManager when receiving the StanzaSentEvent
-        } else {
-          _log.fine('_canSendData() returned false.');
-        }
+      // This uses the StreamManager to behave like a send queue
+      if (await _canSendData()) {
+        _socket.write(stanzaString);
 
-        _log.fine('Running post stanza handlers..');
-        await _runOutgoingPostStanzaHandlers(
+        // Try to ack every stanza
+        // NOTE: Here we have send an Ack request nonza. This is now done by StreamManagementManager when receiving the StanzaSentEvent
+      } else {
+        _log.fine('_canSendData() returned false.');
+      }
+
+      _log.fine('Running post stanza handlers..');
+      await _runOutgoingPostStanzaHandlers(
+        stanza_,
+        initial: StanzaHandlerData(
+          false,
+          false,
+          null,
           stanza_,
-          initial: StanzaHandlerData(
-            false,
-            false,
-            null,
-            stanza_,
-          ),
-        );
-        _log.fine('Done');
+        ),
+      );
+      _log.fine('Done');
 
-        if (awaitable) {
-          future = _awaitingResponse[id]!.future;
-        }
+      if (awaitable) {
+        future = _awaitingResponse[key]!.future;
+      }
 
-        _log.fine('Releasing lock for $id');
+      _log.fine('Releasing lock for ${data.stanza.id}');
     });
 
     return future;
@@ -630,8 +691,12 @@ class XmppConnection {
     return state;
   }
 
-  Future<StanzaHandlerData> _runIncomingStanzaHandlers(Stanza stanza) async {
-    return _runStanzaHandlers(_incomingStanzaHandlers, stanza);
+  Future<StanzaHandlerData> _runIncomingStanzaHandlers(Stanza stanza, { StanzaHandlerData? initial }) async {
+    return _runStanzaHandlers(_incomingStanzaHandlers, stanza, initial: initial);
+  }
+
+  Future<StanzaHandlerData> _runIncomingPreStanzaHandlers(Stanza stanza) async {
+    return _runStanzaHandlers(_incomingPreStanzaHandlers, stanza);
   }
 
   Future<StanzaHandlerData> _runOutgoingPreStanzaHandlers(Stanza stanza, { StanzaHandlerData? initial }) async {
@@ -673,20 +738,24 @@ class XmppConnection {
 
     // Run the incoming stanza handlers and bounce with an error if no manager handled
     // it.
-    final incomingHandlers = await _runIncomingStanzaHandlers(stanza);
-    final prefix = incomingHandlers.encrypted ?
+    final incomingPreHandlers = await _runIncomingPreStanzaHandlers(stanza);
+    final prefix = incomingPreHandlers.encrypted && incomingPreHandlers.other['encryption_error'] == null ?
       '(Encrypted) ' :
       '';
-    _log.finest('<== $prefix${incomingHandlers.stanza.toXml()}');
+    _log.finest('<== $prefix${incomingPreHandlers.stanza.toXml()}');
 
     // See if we are waiting for this stanza
-    final id = stanza.attributes['id'] as String?;
+    final id = incomingPreHandlers.stanza.attributes['id'] as String?;
     var awaited = false;
     await _awaitingResponseLock.synchronized(() async {
-      if (id != null && _awaitingResponse.containsKey(id)) {
-        _awaitingResponse[id]!.complete(incomingHandlers.stanza);
-        _awaitingResponse.remove(id);
-        awaited = true;
+      if (id != null && incomingPreHandlers.stanza.from != null) {
+        final key = _StanzaAwaitableData(incomingPreHandlers.stanza.from!, id);
+        final comp = _awaitingResponse[key];
+        if (comp != null) {
+          comp.complete(incomingPreHandlers.stanza);
+          _awaitingResponse.remove(key);
+          awaited = true;
+        }
       }
     });
 
@@ -695,8 +764,19 @@ class XmppConnection {
     }
 
     // Only bounce if the stanza has neither been awaited, nor handled.
+    final incomingHandlers = await _runIncomingStanzaHandlers(
+      incomingPreHandlers.stanza,
+      initial: StanzaHandlerData(
+        false,
+        incomingPreHandlers.cancel,
+        incomingPreHandlers.cancelReason,
+        incomingPreHandlers.stanza,
+        encrypted: incomingPreHandlers.encrypted,
+        other: incomingPreHandlers.other,
+      ),
+    );
     if (!incomingHandlers.done) {
-      handleUnhandledStanza(this, stanza);
+      handleUnhandledStanza(this, incomingPreHandlers.stanza);
     }
   }
 
@@ -742,6 +822,7 @@ class XmppConnection {
   /// a disco sweep among other things.
   Future<void> _onNegotiationsDone() async {
     // Set the connection state
+    await _resetIsConnectionRunning();
     await _setConnectionState(XmppConnectionState.connected);
 
     // Resolve the connection completion future
@@ -765,6 +846,7 @@ class XmppConnection {
     final result = await _currentNegotiator!.negotiate(nonza);
     if (result.isType<NegotiatorError>()) {
       _log.severe('Negotiator returned an error');
+      await _resetIsConnectionRunning();
       await handleError(result.get<NegotiatorError>());
       return;
     }
@@ -788,6 +870,8 @@ class XmppConnection {
         if (_isMandatoryNegotiationDone(_streamFeatures) && !_isNegotiationPossible(_streamFeatures)) {
           _log.finest('Negotiations done!');
           _updateRoutingState(RoutingState.handleStanzas);
+          await _reconnectionPolicy.onSuccess();
+          await _resetIsConnectionRunning();
           await _onNegotiationsDone();
         } else {
           _currentNegotiator = getNextNegotiator(_streamFeatures);
@@ -811,6 +895,8 @@ class XmppConnection {
         _log.finest('Negotiations done!');
 
         _updateRoutingState(RoutingState.handleStanzas);
+        await _reconnectionPolicy.onSuccess();
+        await _resetIsConnectionRunning();
         await _onNegotiationsDone();
       } else {
         _log.finest('Picking new negotiator...');
@@ -827,6 +913,8 @@ class XmppConnection {
       _log.finest('Negotiator wants to skip the remaining negotiation... Negotiations (assumed) done!');
 
       _updateRoutingState(RoutingState.handleStanzas);
+      await _reconnectionPolicy.onSuccess();
+      await _resetIsConnectionRunning();
       await _onNegotiationsDone();
       break;
     }
@@ -925,9 +1013,10 @@ class XmppConnection {
   }
 
   /// To be called when we lost the network connection.
-  void _onNetworkConnectionLost() {
+  Future<void> _onNetworkConnectionLost() async {
     _socket.close();
-    _setConnectionState(XmppConnectionState.notConnected);
+    await _resetIsConnectionRunning();
+    await _setConnectionState(XmppConnectionState.notConnected);
   }
 
   /// Attempt to gracefully close the session
@@ -937,7 +1026,6 @@ class XmppConnection {
 
   Future<void> _disconnect({required XmppConnectionState state, bool triggeredByUser = true}) async {
     _reconnectionPolicy.setShouldReconnect(false);
-    _socketClosureTriggersReconnect = false;
 
     if (triggeredByUser) {
       getPresenceManager().sendUnavailablePresence();
@@ -968,11 +1056,12 @@ class XmppConnection {
   
   /// Like [connect] but the Future resolves when the resource binding is either done or
   /// SASL has failed.
-  Future<XmppConnectionResult> connectAwaitable({ String? lastResource }) {
+  Future<XmppConnectionResult> connectAwaitable({ String? lastResource }) async {
     _runPreConnectionAssertions();
+    await _resetIsConnectionRunning();
     _connectionCompleter = Completer();
     _log.finest('Calling connect() from connectAwaitable');
-    connect(lastResource: lastResource);
+    await connect(lastResource: lastResource);
     return _connectionCompleter!.future;
   }
  
@@ -984,6 +1073,7 @@ class XmppConnection {
     }
     
     _runPreConnectionAssertions();
+    await _resetIsConnectionRunning();
     _reconnectionPolicy.setShouldReconnect(true);
     
     if (lastResource != null) {
@@ -991,7 +1081,6 @@ class XmppConnection {
     }
 
     await _reconnectionPolicy.reset();
-    _socketClosureTriggersReconnect = true;
     await _sendEvent(ConnectingEvent());
 
     final smManager = getStreamManagementManager();

packages/moxxmpp/lib/src/events.dart

@@ -1,14 +1,17 @@
 import 'package:moxxmpp/src/connection.dart';
 import 'package:moxxmpp/src/jid.dart';
 import 'package:moxxmpp/src/managers/data.dart';
+import 'package:moxxmpp/src/roster/roster.dart';
 import 'package:moxxmpp/src/stanza.dart';
 import 'package:moxxmpp/src/xeps/xep_0030/types.dart';
 import 'package:moxxmpp/src/xeps/xep_0060/xep_0060.dart';
 import 'package:moxxmpp/src/xeps/xep_0066.dart';
 import 'package:moxxmpp/src/xeps/xep_0085.dart';
+import 'package:moxxmpp/src/xeps/xep_0334.dart';
 import 'package:moxxmpp/src/xeps/xep_0359.dart';
 import 'package:moxxmpp/src/xeps/xep_0385.dart';
 import 'package:moxxmpp/src/xeps/xep_0424.dart';
+import 'package:moxxmpp/src/xeps/xep_0444.dart';
 import 'package:moxxmpp/src/xeps/xep_0446.dart';
 import 'package:moxxmpp/src/xeps/xep_0447.dart';
 import 'package:moxxmpp/src/xeps/xep_0461.dart';
@@ -51,6 +54,22 @@ class StreamResumedEvent extends XmppEvent {
 /// Triggered when stream resumption failed
 class StreamResumeFailedEvent extends XmppEvent {}
 
+/// Triggered when the roster has been modified
+class RosterUpdatedEvent extends XmppEvent {
+  RosterUpdatedEvent(this.removed, this.modified, this.added);
+
+  /// A list of bare JIDs that are removed from the roster
+  final List<String> removed;
+
+  /// A list of XmppRosterItems that are modified. Can be correlated with one's cache
+  /// using the jid attribute.
+  final List<XmppRosterItem> modified;
+
+  /// A list of XmppRosterItems that are added to the roster.
+  final List<XmppRosterItem> added;
+}
+
+/// Triggered when a message is received
 class MessageEvent extends XmppEvent {
   MessageEvent({
     required this.body,
@@ -75,6 +94,9 @@ class MessageEvent extends XmppEvent {
     this.funCancellation,
     this.messageRetraction,
     this.messageCorrectionId,
+    this.messageReactions,
+    this.messageProcessingHints,
+    this.stickerPackId,
   });
   final StanzaError? error;
   final String body;
@@ -97,6 +119,9 @@ class MessageEvent extends XmppEvent {
   final bool encrypted;
   final MessageRetractionData? messageRetraction;
   final String? messageCorrectionId;
+  final MessageReactions? messageReactions;
+  final List<MessageProcessingHint>? messageProcessingHints;
+  final String? stickerPackId;
   final Map<String, dynamic> other;
 }
 

packages/moxxmpp/lib/src/jid.dart

@@ -1,83 +1,72 @@
 import 'package:meta/meta.dart';
 
+/// Represents a Jabber ID in parsed form.
 @immutable
 class JID {
-
   const JID(this.local, this.domain, this.resource);
 
+  /// Parses the string [jid] into a JID instance.
   factory JID.fromString(String jid) {
-    // 0: Parsing either the local or domain part
-    // 1: Parsing the domain part
-    // 2: Parsing the resource
-    var state = 0;
-    var buffer = '';
-    var local_ = '';
-    var domain_ = '';
-    var resource_ = '';
-    
-    for (var i = 0; i < jid.length; i++) {
-      final c = jid[i];
-      final eol = i == jid.length - 1;
-      
-      switch (state) {
-        case 0: {
-          if (c == '@') {
-            local_ = buffer;
-            buffer = '';
-            state = 1;
-          } else if (c == '/') {
-            domain_ = buffer;
-            buffer = '';
-            state = 2;
-          } else if (eol) {
-            domain_ = buffer + c;
-          } else {
-            buffer += c;
-          }
-        }
-        break;
-        case 1: {
-          if (c == '/') {
-            domain_ = buffer;
-            buffer = '';
-            state = 2;
-          } else if (eol) {
-            domain_ = buffer;
+    // Algorithm taken from here: https://blog.samwhited.com/2021/02/xmpp-addresses/
+    var localPart = '';
+    var domainPart = '';
+    var resourcePart = '';
 
-            if (c != ' ') {
-              domain_ = domain_ + c;
-            }
-          } else if (c != ' ') {
-            buffer += c;
-          }
-        }
-        break;
-        case 2: {
-          if (eol) {
-            resource_ = buffer;
+    final slashParts = jid.split('/');
+    if (slashParts.length == 1) {
+      resourcePart = '';
+    } else {
+      resourcePart = slashParts.sublist(1).join('/');
 
-            if (c != ' ') {
-              resource_ = resource_ + c;
-            }
-          } else if (c != ''){
-            buffer += c;
-          }
-        }
-      }
+      assert(resourcePart.isNotEmpty, 'Resource part cannot be there and empty');
     }
 
-    return JID(local_, domain_, resource_);
+    final atParts = slashParts.first.split('@');
+    if (atParts.length == 1) {
+      localPart = '';
+      domainPart = atParts.first;
+    } else {
+      localPart = atParts.first;
+      domainPart = atParts.sublist(1).join('@');
+
+      assert(localPart.isNotEmpty, 'Local part cannot be there and empty');
+    }
+
+    return JID(
+      localPart,
+      domainPart.endsWith('.') ?
+        domainPart.substring(0, domainPart.length - 1) :
+        domainPart,
+      resourcePart,
+    );
   }
   final String local;
   final String domain;
   final String resource;
 
+  /// Returns true if the JID is bare.
   bool isBare() => resource.isEmpty;
+
+  /// Returns true if the JID is full.
   bool isFull() => resource.isNotEmpty;
 
+  /// Converts the JID into a bare JID.
   JID toBare() => JID(local, domain, '');
+
+  /// Converts the JID into one with a resource part of [resource].
   JID withResource(String resource) => JID(local, domain, resource);
+
+  /// Compares the JID with [other]. This function assumes that JID and [other]
+  /// are bare, i.e. only the domain- and localparts are compared. If [ensureBare]
+  /// is optionally set to true, then [other] MUST be bare. Otherwise, false is returned.
+  bool bareCompare(JID other, { bool ensureBare = false }) {
+    if (ensureBare && !other.isBare()) return false;
+
+    return local == other.local && domain == other.domain;
+  }
   
+  /// Converts to JID instance into its string representation of
+  /// localpart@domainpart/resource.
   @override
   String toString() {
     var result = '';

packages/moxxmpp/lib/src/managers/attributes.dart

@@ -1,5 +1,4 @@
 import 'dart:async';
-
 import 'package:moxxmpp/src/connection.dart';
 import 'package:moxxmpp/src/events.dart';
 import 'package:moxxmpp/src/jid.dart';
@@ -11,7 +10,6 @@ import 'package:moxxmpp/src/stanza.dart';
 import 'package:moxxmpp/src/stringxml.dart';
 
 class XmppManagerAttributes {
-  
   XmppManagerAttributes({
     required this.sendStanza,
     required this.sendNonza,

packages/moxxmpp/lib/src/managers/base.dart

@@ -21,18 +21,28 @@ abstract class XmppManagerBase {
   }
 
   /// Return the StanzaHandlers associated with this manager that deal with stanzas we
-  /// send. These are run before the stanza is sent.
+  /// send. These are run before the stanza is sent. The higher the value of the
+  /// handler's priority, the earlier it is run.
   List<StanzaHandler> getOutgoingPreStanzaHandlers() => [];
 
   /// Return the StanzaHandlers associated with this manager that deal with stanzas we
-  /// send. These are run after the stanza is sent.
+  /// send. These are run after the stanza is sent. The higher the value of the
+  /// handler's priority, the earlier it is run.
   List<StanzaHandler> getOutgoingPostStanzaHandlers() => [];
   
   /// Return the StanzaHandlers associated with this manager that deal with stanzas we
-  /// receive.
+  /// receive. The higher the value of the
+  /// handler's priority, the earlier it is run.
   List<StanzaHandler> getIncomingStanzaHandlers() => [];
+
+  /// Return the StanzaHandlers associated with this manager that deal with stanza handlers
+  /// that have to run before the main ones run. This is useful, for example, for OMEMO
+  /// as we have to decrypt the stanza before we do anything else. The higher the value
+  /// of the handler's priority, the earlier it is run.
+  List<StanzaHandler> getIncomingPreStanzaHandlers() => [];
   
-  /// Return the NonzaHandlers associated with this manager.
+  /// Return the NonzaHandlers associated with this manager. The higher the value of the
+  /// handler's priority, the earlier it is run.
   List<NonzaHandler> getNonzaHandlers() => [];
 
   /// Return a list of features that should be included in a disco response.

packages/moxxmpp/lib/src/managers/data.dart

@@ -7,6 +7,7 @@ import 'package:moxxmpp/src/xeps/xep_0359.dart';
 import 'package:moxxmpp/src/xeps/xep_0380.dart';
 import 'package:moxxmpp/src/xeps/xep_0385.dart';
 import 'package:moxxmpp/src/xeps/xep_0424.dart';
+import 'package:moxxmpp/src/xeps/xep_0444.dart';
 import 'package:moxxmpp/src/xeps/xep_0446.dart';
 import 'package:moxxmpp/src/xeps/xep_0447.dart';
 import 'package:moxxmpp/src/xeps/xep_0461.dart';
@@ -61,6 +62,10 @@ class StanzaHandlerData with _$StanzaHandlerData {
       MessageRetractionData? messageRetraction,
       // If non-null, then the message is a correction for the specified stanza Id
       String? lastMessageCorrectionSid,
+      // Reactions data
+      MessageReactions? messageReactions,
+      // The Id of the sticker pack this sticker belongs to
+      String? stickerPackId,
     }
   ) = _StanzaHandlerData;
 }

packages/moxxmpp/lib/src/managers/data.freezed.dart

@@ -59,7 +59,11 @@ mixin _$StanzaHandlerData {
 // retracted
   MessageRetractionData? get messageRetraction =>
       throw _privateConstructorUsedError; // If non-null, then the message is a correction for the specified stanza Id
-  String? get lastMessageCorrectionSid => throw _privateConstructorUsedError;
+  String? get lastMessageCorrectionSid =>
+      throw _privateConstructorUsedError; // Reactions data
+  MessageReactions? get messageReactions =>
+      throw _privateConstructorUsedError; // The Id of the sticker pack this sticker belongs to
+  String? get stickerPackId => throw _privateConstructorUsedError;
 
   @JsonKey(ignore: true)
   $StanzaHandlerDataCopyWith<StanzaHandlerData> get copyWith =>
@@ -94,7 +98,9 @@ abstract class $StanzaHandlerDataCopyWith<$Res> {
       DelayedDelivery? delayedDelivery,
       Map<String, dynamic> other,
       MessageRetractionData? messageRetraction,
-      String? lastMessageCorrectionSid});
+      String? lastMessageCorrectionSid,
+      MessageReactions? messageReactions,
+      String? stickerPackId});
 }
 
 /// @nodoc
@@ -131,6 +137,8 @@ class _$StanzaHandlerDataCopyWithImpl<$Res>
     Object? other = freezed,
     Object? messageRetraction = freezed,
     Object? lastMessageCorrectionSid = freezed,
+    Object? messageReactions = freezed,
+    Object? stickerPackId = freezed,
   }) {
     return _then(_value.copyWith(
       done: done == freezed
@@ -225,6 +233,14 @@ class _$StanzaHandlerDataCopyWithImpl<$Res>
           ? _value.lastMessageCorrectionSid
           : lastMessageCorrectionSid // ignore: cast_nullable_to_non_nullable
               as String?,
+      messageReactions: messageReactions == freezed
+          ? _value.messageReactions
+          : messageReactions // ignore: cast_nullable_to_non_nullable
+              as MessageReactions?,
+      stickerPackId: stickerPackId == freezed
+          ? _value.stickerPackId
+          : stickerPackId // ignore: cast_nullable_to_non_nullable
+              as String?,
     ));
   }
 }
@@ -259,7 +275,9 @@ abstract class _$$_StanzaHandlerDataCopyWith<$Res>
       DelayedDelivery? delayedDelivery,
       Map<String, dynamic> other,
       MessageRetractionData? messageRetraction,
-      String? lastMessageCorrectionSid});
+      String? lastMessageCorrectionSid,
+      MessageReactions? messageReactions,
+      String? stickerPackId});
 }
 
 /// @nodoc
@@ -298,6 +316,8 @@ class __$$_StanzaHandlerDataCopyWithImpl<$Res>
     Object? other = freezed,
     Object? messageRetraction = freezed,
     Object? lastMessageCorrectionSid = freezed,
+    Object? messageReactions = freezed,
+    Object? stickerPackId = freezed,
   }) {
     return _then(_$_StanzaHandlerData(
       done == freezed
@@ -392,6 +412,14 @@ class __$$_StanzaHandlerDataCopyWithImpl<$Res>
           ? _value.lastMessageCorrectionSid
           : lastMessageCorrectionSid // ignore: cast_nullable_to_non_nullable
               as String?,
+      messageReactions: messageReactions == freezed
+          ? _value.messageReactions
+          : messageReactions // ignore: cast_nullable_to_non_nullable
+              as MessageReactions?,
+      stickerPackId: stickerPackId == freezed
+          ? _value.stickerPackId
+          : stickerPackId // ignore: cast_nullable_to_non_nullable
+              as String?,
     ));
   }
 }
@@ -418,7 +446,9 @@ class _$_StanzaHandlerData implements _StanzaHandlerData {
       this.delayedDelivery,
       final Map<String, dynamic> other = const <String, dynamic>{},
       this.messageRetraction,
-      this.lastMessageCorrectionSid})
+      this.lastMessageCorrectionSid,
+      this.messageReactions,
+      this.stickerPackId})
       : _other = other;
 
 // Indicates to the runner that processing is now done. This means that all
@@ -501,10 +531,16 @@ class _$_StanzaHandlerData implements _StanzaHandlerData {
 // If non-null, then the message is a correction for the specified stanza Id
   @override
   final String? lastMessageCorrectionSid;
+// Reactions data
+  @override
+  final MessageReactions? messageReactions;
+// The Id of the sticker pack this sticker belongs to
+  @override
+  final String? stickerPackId;
 
   @override
   String toString() {
-    return 'StanzaHandlerData(done: $done, cancel: $cancel, cancelReason: $cancelReason, stanza: $stanza, retransmitted: $retransmitted, sims: $sims, sfs: $sfs, oob: $oob, stableId: $stableId, reply: $reply, chatState: $chatState, isCarbon: $isCarbon, deliveryReceiptRequested: $deliveryReceiptRequested, isMarkable: $isMarkable, fun: $fun, funReplacement: $funReplacement, funCancellation: $funCancellation, encrypted: $encrypted, encryptionType: $encryptionType, delayedDelivery: $delayedDelivery, other: $other, messageRetraction: $messageRetraction, lastMessageCorrectionSid: $lastMessageCorrectionSid)';
+    return 'StanzaHandlerData(done: $done, cancel: $cancel, cancelReason: $cancelReason, stanza: $stanza, retransmitted: $retransmitted, sims: $sims, sfs: $sfs, oob: $oob, stableId: $stableId, reply: $reply, chatState: $chatState, isCarbon: $isCarbon, deliveryReceiptRequested: $deliveryReceiptRequested, isMarkable: $isMarkable, fun: $fun, funReplacement: $funReplacement, funCancellation: $funCancellation, encrypted: $encrypted, encryptionType: $encryptionType, delayedDelivery: $delayedDelivery, other: $other, messageRetraction: $messageRetraction, lastMessageCorrectionSid: $lastMessageCorrectionSid, messageReactions: $messageReactions, stickerPackId: $stickerPackId)';
   }
 
   @override
@@ -544,7 +580,11 @@ class _$_StanzaHandlerData implements _StanzaHandlerData {
             const DeepCollectionEquality()
                 .equals(other.messageRetraction, messageRetraction) &&
             const DeepCollectionEquality().equals(
-                other.lastMessageCorrectionSid, lastMessageCorrectionSid));
+                other.lastMessageCorrectionSid, lastMessageCorrectionSid) &&
+            const DeepCollectionEquality()
+                .equals(other.messageReactions, messageReactions) &&
+            const DeepCollectionEquality()
+                .equals(other.stickerPackId, stickerPackId));
   }
 
   @override
@@ -572,7 +612,9 @@ class _$_StanzaHandlerData implements _StanzaHandlerData {
         const DeepCollectionEquality().hash(delayedDelivery),
         const DeepCollectionEquality().hash(_other),
         const DeepCollectionEquality().hash(messageRetraction),
-        const DeepCollectionEquality().hash(lastMessageCorrectionSid)
+        const DeepCollectionEquality().hash(lastMessageCorrectionSid),
+        const DeepCollectionEquality().hash(messageReactions),
+        const DeepCollectionEquality().hash(stickerPackId)
       ]);
 
   @JsonKey(ignore: true)
@@ -603,7 +645,9 @@ abstract class _StanzaHandlerData implements StanzaHandlerData {
       final DelayedDelivery? delayedDelivery,
       final Map<String, dynamic> other,
       final MessageRetractionData? messageRetraction,
-      final String? lastMessageCorrectionSid}) = _$_StanzaHandlerData;
+      final String? lastMessageCorrectionSid,
+      final MessageReactions? messageReactions,
+      final String? stickerPackId}) = _$_StanzaHandlerData;
 
   @override // Indicates to the runner that processing is now done. This means that all
 // pre-processing is done and no other handlers should be consulted.
@@ -658,6 +702,10 @@ abstract class _StanzaHandlerData implements StanzaHandlerData {
   MessageRetractionData? get messageRetraction;
   @override // If non-null, then the message is a correction for the specified stanza Id
   String? get lastMessageCorrectionSid;
+  @override // Reactions data
+  MessageReactions? get messageReactions;
+  @override // The Id of the sticker pack this sticker belongs to
+  String? get stickerPackId;
   @override
   @JsonKey(ignore: true)
   _$$_StanzaHandlerDataCopyWith<_$_StanzaHandlerData> get copyWith =>

packages/moxxmpp/lib/src/managers/handlers.dart

@@ -5,7 +5,6 @@ import 'package:moxxmpp/src/stanza.dart';
 import 'package:moxxmpp/src/stringxml.dart';
 
 abstract class Handler {
-
   const Handler(this.matchStanzas, { this.nonzaTag, this.nonzaXmlns });
   final String? nonzaTag;
   final String? nonzaXmlns;
@@ -32,7 +31,6 @@ abstract class Handler {
 }
 
 class NonzaHandler extends Handler {
-
   NonzaHandler({
       required this.callback,
       String? nonzaTag,
@@ -46,7 +44,6 @@ class NonzaHandler extends Handler {
 }
 
 class StanzaHandler extends Handler {
-
   StanzaHandler({
       required this.callback,
       this.tagXmlns,

packages/moxxmpp/lib/src/managers/namespaces.dart

@@ -26,3 +26,5 @@ const cryptographicHashManager = 'org.moxxmpp.cryptographichashmanager';
 const delayedDeliveryManager = 'org.moxxmpp.delayeddeliverymanager';
 const messageRetractionManager = 'org.moxxmpp.messageretractionmanager';
 const lastMessageCorrectionManager = 'org.moxxmpp.lastmessagecorrectionmanager';
+const messageReactionsManager = 'org.moxxmpp.messagereactionsmanager';
+const stickersManager = 'org.moxxmpp.stickersmanager';

packages/moxxmpp/lib/src/message.dart

@@ -1,3 +1,4 @@
+import 'package:moxlib/moxlib.dart';
 import 'package:moxxmpp/src/events.dart';
 import 'package:moxxmpp/src/jid.dart';
 import 'package:moxxmpp/src/managers/base.dart';
@@ -13,12 +14,20 @@ import 'package:moxxmpp/src/xeps/xep_0085.dart';
 import 'package:moxxmpp/src/xeps/xep_0184.dart';
 import 'package:moxxmpp/src/xeps/xep_0308.dart';
 import 'package:moxxmpp/src/xeps/xep_0333.dart';
+import 'package:moxxmpp/src/xeps/xep_0334.dart';
 import 'package:moxxmpp/src/xeps/xep_0359.dart';
 import 'package:moxxmpp/src/xeps/xep_0424.dart';
+import 'package:moxxmpp/src/xeps/xep_0444.dart';
 import 'package:moxxmpp/src/xeps/xep_0446.dart';
 import 'package:moxxmpp/src/xeps/xep_0447.dart';
 import 'package:moxxmpp/src/xeps/xep_0448.dart';
+import 'package:moxxmpp/src/xeps/xep_0461.dart';
 
+/// Data used to build a message stanza.
+///
+/// [setOOBFallbackBody] indicates, when using SFS, whether a OOB fallback should be
+/// added. This is recommended when sharing files but may cause issues when the message
+/// stanza should include a SFS element without any fallbacks.
 class MessageDetails {
   const MessageDetails({
     required this.to,
@@ -38,6 +47,10 @@ class MessageDetails {
     this.shouldEncrypt = false,
     this.messageRetraction,
     this.lastMessageCorrectionId,
+    this.messageReactions,
+    this.messageProcessingHints,
+    this.stickerPackId,
+    this.setOOBFallbackBody = true,
   });
   final String to;
   final String? body;
@@ -56,6 +69,10 @@ class MessageDetails {
   final bool shouldEncrypt;
   final MessageRetractionData? messageRetraction;
   final String? lastMessageCorrectionId;
+  final MessageReactions? messageReactions;
+  final String? stickerPackId;
+  final List<MessageProcessingHint>? messageProcessingHints;
+  final bool setOOBFallbackBody;
 }
 
 class MessageManager extends XmppManagerBase {
@@ -81,6 +98,11 @@ class MessageManager extends XmppManagerBase {
     final message = state.stanza;
     final body = message.firstTag('body');
 
+    final hints = List<MessageProcessingHint>.empty(growable: true);
+    for (final element in message.findTagsByXmlns(messageProcessingHintsXmlns)) {
+      hints.add(messageProcessingHintFromXml(element)); 
+    }
+    
     getAttributes().sendEvent(MessageEvent(
       body: body != null ? body.innerText() : '',
       fromJid: JID.fromString(message.attributes['from']! as String),
@@ -102,6 +124,11 @@ class MessageManager extends XmppManagerBase {
       encrypted: state.encrypted,
       messageRetraction: state.messageRetraction,
       messageCorrectionId: state.lastMessageCorrectionSid,
+      messageReactions: state.messageReactions,
+      messageProcessingHints: hints.isEmpty ?
+        null :
+        hints,
+      stickerPackId: state.stickerPackId,
       other: state.other,
       error: StanzaError.fromStanza(message),
     ),);
@@ -115,6 +142,11 @@ class MessageManager extends XmppManagerBase {
   /// element to this id. If originId is non-null, then it will create an "origin-id"
   /// child in the message stanza and set its id to originId.
   void sendMessage(MessageDetails details) {
+    assert(
+      implies(details.quoteBody != null, details.quoteFrom != null && details.quoteId != null),
+      'When quoting a message, then quoteFrom and quoteId must also be non-null',
+    );
+
     final stanza = Stanza.message(
       to: details.to,
       type: 'chat',
@@ -123,11 +155,11 @@ class MessageManager extends XmppManagerBase {
     );
 
     if (details.quoteBody != null) {
-      final fallback = '&gt; ${details.quoteBody!}';
-
+      final quote = QuoteData.fromBodies(details.quoteBody!, details.body!);
+        
       stanza
         ..addChild(
-          XMLNode(tag: 'body', text: '$fallback\n${details.body}'),
+          XMLNode(tag: 'body', text: quote.body),
         )
         ..addChild(
           XMLNode.xmlns(
@@ -151,7 +183,7 @@ class MessageManager extends XmppManagerBase {
                 tag: 'body',
                 attributes: <String, String>{
                   'start': '0',
-                  'end': '${fallback.length}'
+                  'end': '${quote.fallbackLength}',
                 },
               )
             ],
@@ -159,7 +191,7 @@ class MessageManager extends XmppManagerBase {
         );
     } else {
       var body = details.body;
-      if (details.sfs != null) {
+      if (details.sfs != null && details.setOOBFallbackBody) {
         // TODO(Unknown): Maybe find a better solution
         final firstSource = details.sfs!.sources.first;
         if (firstSource is StatelessFileSharingUrlSource) {
@@ -171,9 +203,11 @@ class MessageManager extends XmppManagerBase {
         body = details.messageRetraction!.fallback;
       }
 
-      stanza.addChild(
-        XMLNode(tag: 'body', text: body),
-      );
+      if (body != null) {
+        stanza.addChild(
+          XMLNode(tag: 'body', text: body),
+        );
+      }
     }
 
     if (details.requestDeliveryReceipt) {
@@ -190,7 +224,7 @@ class MessageManager extends XmppManagerBase {
       stanza.addChild(details.sfs!.toXML());
 
       final source = details.sfs!.sources.first;
-      if (source is StatelessFileSharingUrlSource) {
+      if (source is StatelessFileSharingUrlSource && details.setOOBFallbackBody) {
         // SFS recommends OOB as a fallback
         stanza.addChild(constructOOBNode(OOBData(url: source.url)));
       }
@@ -261,6 +295,28 @@ class MessageManager extends XmppManagerBase {
         ),
       );
     }
+
+    if (details.messageReactions != null) {
+      stanza.addChild(details.messageReactions!.toXml());
+    }
+    
+    if (details.messageProcessingHints != null) {
+      for (final hint in details.messageProcessingHints!) {
+        stanza.addChild(hint.toXml());
+      }
+    }
+
+    if (details.stickerPackId != null) {
+      stanza.addChild(
+        XMLNode.xmlns(
+          tag: 'sticker',
+          xmlns: stickersXmlns,
+          attributes: {
+            'pack': details.stickerPackId!,
+          },
+        ),
+      );
+    }
     
     getAttributes().sendStanza(stanza, awaitable: false);
   }

packages/moxxmpp/lib/src/namespaces.dart

@@ -123,9 +123,12 @@ const fasteningXmlns = 'urn:xmpp:fasten:0';
 // XEP-0424
 const messageRetractionXmlns = 'urn:xmpp:message-retract:0';
 
-// XEp-0428
+// XEP-0428
 const fallbackIndicationXmlns = 'urn:xmpp:fallback:0';
 
+// XEP-0444
+const messageReactionsXmlns = 'urn:xmpp:reactions:0';
+
 // XEP-0446
 const fileMetadataXmlns = 'urn:xmpp:file:metadata:0';
 
@@ -138,6 +141,9 @@ const sfsEncryptionAes128GcmNoPaddingXmlns = 'urn:xmpp:ciphers:aes-128-gcm-nopad
 const sfsEncryptionAes256GcmNoPaddingXmlns = 'urn:xmpp:ciphers:aes-256-gcm-nopadding:0';
 const sfsEncryptionAes256CbcPkcs7Xmlns = 'urn:xmpp:ciphers:aes-256-cbc-pkcs7:0';
 
+// XEP-0449
+const stickersXmlns = 'urn:xmpp:stickers:0';
+
 // XEP-0461
 const replyXmlns = 'urn:xmpp:reply:0';
 const fallbackXmlns = 'urn:xmpp:feature-fallback:0';

packages/moxxmpp/lib/src/reconnect.dart

@@ -4,27 +4,33 @@ import 'package:logging/logging.dart';
 import 'package:meta/meta.dart';
 import 'package:synchronized/synchronized.dart';
 
-abstract class ReconnectionPolicy {
+/// A callback function to be called when the connection to the server has been lost.
+typedef ConnectionLostCallback = Future<void> Function();
 
-  ReconnectionPolicy()
-    : _shouldAttemptReconnection = false,
-      _isReconnecting = false,
-      _isReconnectingLock = Lock();
+/// A function that, when called, causes the XmppConnection to connect to the server, if
+/// another reconnection is not already running.
+typedef PerformReconnectFunction = Future<void> Function();
+
+abstract class ReconnectionPolicy {
   /// Function provided by XmppConnection that allows the policy
   /// to perform a reconnection.
-  Future<void> Function()? performReconnect;
+  PerformReconnectFunction? performReconnect;
+
   /// Function provided by XmppConnection that allows the policy
   /// to say that we lost the connection.
-  void Function()? triggerConnectionLost;
+  ConnectionLostCallback? triggerConnectionLost;
+
   /// Indicate if should try to reconnect.
-  bool _shouldAttemptReconnection;
+  bool _shouldAttemptReconnection = false;
+
   /// Indicate if a reconnection attempt is currently running.
-  bool _isReconnecting;
+  bool _isReconnecting = false;
+
   /// And the corresponding lock
-  final Lock _isReconnectingLock;
+  final Lock _isReconnectingLock = Lock();
   
   /// Called by XmppConnection to register the policy.
-  void register(Future<void> Function() performReconnect, void Function() triggerConnectionLost) {
+  void register(PerformReconnectFunction performReconnect, ConnectionLostCallback triggerConnectionLost) {
     this.performReconnect = performReconnect;
     this.triggerConnectionLost = triggerConnectionLost;
 

packages/moxxmpp/lib/src/rfcs/rfc_4790.dart

@@ -24,3 +24,28 @@ int ioctetSortComparator(String a, String b) {
   
   return 1;
 }
+
+int ioctetSortComparatorRaw(List<int> a, List<int> b) {
+  if (a.isEmpty && b.isEmpty) {
+    return 0;
+  }
+
+  if (a.isEmpty && b.isNotEmpty) {
+    return -1;
+  }
+
+  if (a.isNotEmpty && b.isEmpty) {
+    return 1;
+  }
+
+  if (a[0] == b[0]) {
+    return ioctetSortComparatorRaw(a.sublist(1), b.sublist(1));
+  }
+
+  // TODO(Unknown): Is this correct?
+  if (a[0] < b[0]) {
+    return -1;
+  }
+  
+  return 1;
+}

packages/moxxmpp/lib/src/roster/roster.dart

@@ -1,5 +1,8 @@
-import 'package:moxxmpp/src/events.dart';
+import 'dart:async';
+import 'package:collection/collection.dart';
+import 'package:meta/meta.dart';
 import 'package:moxxmpp/src/jid.dart';
+import 'package:moxxmpp/src/managers/attributes.dart';
 import 'package:moxxmpp/src/managers/base.dart';
 import 'package:moxxmpp/src/managers/data.dart';
 import 'package:moxxmpp/src/managers/handlers.dart';
@@ -8,17 +11,42 @@ import 'package:moxxmpp/src/namespaces.dart';
 import 'package:moxxmpp/src/negotiators/namespaces.dart';
 import 'package:moxxmpp/src/negotiators/negotiator.dart';
 import 'package:moxxmpp/src/roster/errors.dart';
+import 'package:moxxmpp/src/roster/state.dart';
 import 'package:moxxmpp/src/stanza.dart';
 import 'package:moxxmpp/src/stringxml.dart';
 import 'package:moxxmpp/src/types/result.dart';
 
+@immutable
 class XmppRosterItem {
-  XmppRosterItem({ required this.jid, required this.subscription, this.ask, this.name, this.groups = const [] });
+  const XmppRosterItem({ required this.jid, required this.subscription, this.ask, this.name, this.groups = const [] });
   final String jid;
   final String? name;
   final String subscription;
   final String? ask;
   final List<String> groups;
+
+  @override
+  bool operator==(Object other) {
+    return other is XmppRosterItem &&
+           other.jid == jid &&
+           other.name == name &&
+           other.subscription == subscription &&
+           other.ask == ask &&
+           const ListEquality<String>().equals(other.groups, groups);
+  }
+
+  @override
+  int get hashCode => jid.hashCode ^ name.hashCode ^ subscription.hashCode ^ ask.hashCode ^ groups.hashCode;
+  
+  @override
+  String toString() {
+    return 'XmppRosterItem('
+           'jid: $jid, '
+           'name: $name, '
+           'subscription: $subscription, '
+           'ask: $ask, '
+           'groups: $groups)';
+  }
 }
 
 enum RosterRemovalResult {
@@ -28,13 +56,13 @@ enum RosterRemovalResult {
 }
 
 class RosterRequestResult {
-  RosterRequestResult({ required this.items, this.ver });
+  RosterRequestResult(this.items, this.ver);
   List<XmppRosterItem> items;
   String? ver;
 }
 
-class RosterPushEvent extends XmppEvent {
-  RosterPushEvent({ required this.item, this.ver });
+class RosterPushResult {
+  RosterPushResult(this.item, this.ver);
   final XmppRosterItem item;
   final String? ver;
 }
@@ -65,9 +93,16 @@ class RosterFeatureNegotiator extends XmppFeatureNegotiatorBase {
 
 /// This manager requires a RosterFeatureNegotiator to be registered.
 class RosterManager extends XmppManagerBase {
+  RosterManager(this._stateManager) : super();
 
-  RosterManager() : _rosterVersion = null, super();
-  String? _rosterVersion;
+  /// The class managing the entire roster state.
+  final BaseRosterStateManager _stateManager;
+
+  @override
+  void register(XmppManagerAttributes attributes) {
+    super.register(attributes);
+    _stateManager.register(attributes.sendEvent); 
+  }
   
   @override
   String getId() => rosterManager;
@@ -87,17 +122,7 @@ class RosterManager extends XmppManagerBase {
 
   @override
   Future<bool> isSupported() async => true; 
-  
-  /// Override-able functions
-  Future<void> commitLastRosterVersion(String version) async {}
-  Future<void> loadLastRosterVersion() async {}
 
-  void setRosterVersion(String ver) {
-    assert(_rosterVersion == null, 'A roster version must not be empty');
-
-    _rosterVersion = ver;
-  }
- 
   Future<StanzaHandlerData> _onRosterPush(Stanza stanza, StanzaHandlerData state) async {
     final attrs = getAttributes();
     final from = stanza.attributes['from'] as String?;
@@ -114,6 +139,7 @@ class RosterManager extends XmppManagerBase {
     }
 
     final query = stanza.firstTag('query', xmlns: rosterXmlns)!;
+    logger.fine('Roster push: ${query.toXml()}');
     final item = query.firstTag('item');
 
     if (item == null) {
@@ -121,21 +147,20 @@ class RosterManager extends XmppManagerBase {
       return state.copyWith(done: true);
     }
 
-    if (query.attributes['ver'] != null) {
-      final ver = query.attributes['ver']! as String;
-      await commitLastRosterVersion(ver);
-      _rosterVersion = ver;
-    }
-    
-    attrs.sendEvent(RosterPushEvent(
-      item: XmppRosterItem(
-        jid: item.attributes['jid']! as String,
-        subscription: item.attributes['subscription']! as String,
-        ask: item.attributes['ask'] as String?,
-        name: item.attributes['name'] as String?, 
+    unawaited(
+      _stateManager.handleRosterPush(
+        RosterPushResult(
+          XmppRosterItem(
+            jid: item.attributes['jid']! as String,
+            subscription: item.attributes['subscription']! as String,
+            ask: item.attributes['ask'] as String?,
+            name: item.attributes['name'] as String?, 
+          ),
+          query.attributes['ver'] as String?,
+        ),
       ),
-      ver: query.attributes['ver'] as String?,
-    ),);
+    );
+    
     await attrs.sendStanza(stanza.reply());
 
     return state.copyWith(done: true);
@@ -145,71 +170,69 @@ class RosterManager extends XmppManagerBase {
   /// the server deems a regular roster response more efficient than n roster pushes.
   Future<Result<RosterRequestResult, RosterError>> _handleRosterResponse(XMLNode? query) async {
     final List<XmppRosterItem> items;
+    String? rosterVersion;
     if (query != null) {
-      items = query.children.map((item) => XmppRosterItem(
-        name: item.attributes['name'] as String?,
-        jid: item.attributes['jid']! as String,
-        subscription: item.attributes['subscription']! as String,
-        ask: item.attributes['ask'] as String?,
-        groups: item.findTags('group').map((groupNode) => groupNode.innerText()).toList(),
-      ),).toList();
+      items = query.children.map(
+        (item) => XmppRosterItem(
+          name: item.attributes['name'] as String?,
+          jid: item.attributes['jid']! as String,
+          subscription: item.attributes['subscription']! as String,
+          ask: item.attributes['ask'] as String?,
+          groups: item.findTags('group').map((groupNode) => groupNode.innerText()).toList(),
+        ),
+      ).toList();
 
-      if (query.attributes['ver'] != null) {
-        final ver_ = query.attributes['ver']! as String;
-        await commitLastRosterVersion(ver_);
-        _rosterVersion = ver_;
-      }
+      rosterVersion = query.attributes['ver'] as String?;
     } else {
       logger.warning('Server response to roster request without roster versioning does not contain a <query /> element, while the type is not error. This violates RFC6121');
       return Result(NoQueryError());
     }
 
-    final ver = query.attributes['ver'] as String?;
-    if (ver != null) {
-      _rosterVersion = ver;
-      await commitLastRosterVersion(ver);
-    }
-    
-    return Result(
-      RosterRequestResult(
-        items: items,
-        ver: ver,
-      ),
+    final result = RosterRequestResult(
+      items,
+      rosterVersion,
     );
 
+    unawaited(
+      _stateManager.handleRosterFetch(result),
+    );
+
+    return Result(result);
   }
   
-  /// Requests the roster following RFC 6121 without using roster versioning.
+  /// Requests the roster following RFC 6121.
   Future<Result<RosterRequestResult, RosterError>> requestRoster() async {
     final attrs = getAttributes();
+    final query = XMLNode.xmlns(
+      tag: 'query',
+      xmlns: rosterXmlns,
+    );
+    final rosterVersion = await _stateManager.getRosterVersion();
+    if (rosterVersion != null && rosterVersioningAvailable()) {
+      query.attributes['ver'] = rosterVersion;
+    }
+
     final response = await attrs.sendStanza(
       Stanza.iq(
         type: 'get',
         children: [
-          XMLNode.xmlns(
-            tag: 'query',
-            xmlns: rosterXmlns,
-          )
+          query,
         ],
       ),
     );
 
     if (response.attributes['type'] != 'result') {
-      logger.warning('Error requesting roster without roster versioning: ${response.toXml()}');
+      logger.warning('Error requesting roster: ${response.toXml()}');
       return Result(UnknownError());
     }
 
-    final query = response.firstTag('query', xmlns: rosterXmlns);
-    return _handleRosterResponse(query);
+    final responseQuery = response.firstTag('query', xmlns: rosterXmlns);
+    return _handleRosterResponse(responseQuery);
   }
 
   /// Requests a series of roster pushes according to RFC6121. Requires that the server
   /// advertises urn:xmpp:features:rosterver in the stream features.
   Future<Result<RosterRequestResult?, RosterError>> requestRosterPushes() async {
-    if (_rosterVersion == null) {
-      await loadLastRosterVersion();
-    }
-
     final attrs = getAttributes();
     final result = await attrs.sendStanza(
       Stanza.iq(
@@ -219,7 +242,7 @@ class RosterManager extends XmppManagerBase {
             tag: 'query',
             xmlns: rosterXmlns,
             attributes: {
-              'ver': _rosterVersion ?? ''
+              'ver': await _stateManager.getRosterVersion() ?? '',
             },
           )
         ],

packages/moxxmpp/lib/src/roster/state.dart

@@ -0,0 +1,220 @@
+import 'package:meta/meta.dart';
+import 'package:moxxmpp/src/events.dart';
+import 'package:moxxmpp/src/roster/roster.dart';
+import 'package:synchronized/synchronized.dart';
+
+class _RosterProcessTriple {
+  const _RosterProcessTriple(this.removed, this.modified, this.added);
+  final String? removed;
+  final XmppRosterItem? modified;
+  final XmppRosterItem? added;
+}
+
+class RosterCacheLoadResult {
+  const RosterCacheLoadResult(this.version, this.roster);
+  final String? version;
+  final List<XmppRosterItem> roster;
+}
+
+/// This class manages the roster state in order to correctly process and persist
+/// roster pushes and facilitate roster versioning requests.
+abstract class BaseRosterStateManager {
+  /// The cached version of the roster. If null, then it has not been loaded yet.
+  List<XmppRosterItem>? _currentRoster;
+
+  /// The cached version of the roster version.
+  String? _currentVersion;
+
+  /// A critical section locking both _currentRoster and _currentVersion.
+  final Lock _lock = Lock();
+
+  /// A function to send an XmppEvent to moxxmpp's main event bus
+  late void Function(XmppEvent) _sendEvent;
+  
+  /// Overrideable function
+  /// Loads the old cached version of the roster and optionally that roster version
+  /// from persistent storage into a RosterCacheLoadResult object.
+  Future<RosterCacheLoadResult> loadRosterCache();
+
+  /// Overrideable function
+  /// Commits the roster data to persistent storage.
+  ///
+  /// [version] is the roster version string. If none was provided, then this value
+  /// is null.
+  ///
+  /// [removed] is a (possibly empty) list of bare JIDs that are removed from the
+  /// roster.
+  ///
+  /// [modified] is a (possibly empty) list of XmppRosterItems that are modified. Correlation with
+  /// the cache is done using its jid attribute.
+  ///
+  /// [added] is a (possibly empty) list of XmppRosterItems that are added by the
+  /// roster push or roster fetch request.
+  Future<void> commitRoster(String? version, List<String> removed, List<XmppRosterItem> modified, List<XmppRosterItem> added);
+
+  /// Internal function. Registers functions from the RosterManger against this
+  /// instance.
+  void register(void Function(XmppEvent) sendEvent) {
+    _sendEvent = sendEvent;
+  }
+  
+  /// Load and cache or return the cached roster version.
+  Future<String?> getRosterVersion() async {
+    return _lock.synchronized(() async {
+      await _loadRosterCache();
+
+      return _currentVersion;
+    });
+  }
+
+  /// A wrapper around _commitRoster that also sends an event to moxxmpp's event
+  /// bus.
+  Future<void> _commitRoster(String? version, List<String> removed, List<XmppRosterItem> modified, List<XmppRosterItem> added) async {
+    _sendEvent(
+      RosterUpdatedEvent(
+        removed,
+        modified,
+        added,
+      ),
+    );
+    
+    await commitRoster(version, removed, modified, added);
+  }
+  
+  /// Loads the cached roster data into memory, if that has not already happened.
+  /// NOTE: Must be called from within the _lock critical section.
+  Future<void> _loadRosterCache() async {
+    if (_currentRoster == null) {
+      final result = await loadRosterCache();
+
+      _currentRoster = result.roster;
+      _currentVersion = result.version;
+    }
+  }
+
+  /// Processes only single XmppRosterItem [item].
+  /// NOTE: Requires to be called from within the _lock critical section.
+  _RosterProcessTriple _handleRosterItem(XmppRosterItem item) {
+    if (item.subscription == 'remove') {
+      // The item has been removed
+      _currentRoster!.removeWhere((i) => i.jid == item.jid);
+      return _RosterProcessTriple(
+        item.jid,
+        null,
+        null,
+      );
+    }
+    
+    final index = _currentRoster!.indexWhere((i) => i.jid == item.jid);
+    if (index == -1) {
+      // The item does not exist
+      _currentRoster!.add(item);
+      return _RosterProcessTriple(
+        null,
+        null,
+        item,
+      );
+    } else if (_currentRoster![index] != item) {
+      // The item is updated
+      _currentRoster![index] = item;
+      return _RosterProcessTriple(
+        null,
+        item,
+        null,
+      );
+    }
+
+    // Item has not been modified or added
+    return const _RosterProcessTriple(
+      null,
+      null,
+      null,
+    );
+  }
+
+  /// Handles a roster push from the RosterManager.
+  Future<void> handleRosterPush(RosterPushResult event) async {
+    await _lock.synchronized(() async {
+      await _loadRosterCache();
+
+      _currentVersion = event.ver;
+      final result = _handleRosterItem(event.item);
+
+      if (result.removed != null) {
+        return _commitRoster(
+          _currentVersion,
+          [result.removed!],
+          [],
+          [],
+        );
+      } else if (result.modified != null) {
+        return _commitRoster(
+          _currentVersion,
+          [],
+          [result.modified!],
+          [],
+        );
+      } else if (result.added != null) {
+        return _commitRoster(
+          _currentVersion,
+          [],
+          [],
+          [result.added!],
+        );
+      }
+    });
+  }
+
+  /// Handles the result from a roster fetch.
+  Future<void> handleRosterFetch(RosterRequestResult result) async {
+    await _lock.synchronized(() async {
+      final removed = List<String>.empty(growable: true);
+      final modified = List<XmppRosterItem>.empty(growable: true);
+      final added = List<XmppRosterItem>.empty(growable: true);
+
+      await _loadRosterCache();
+      
+      _currentVersion = result.ver;
+      for (final item in result.items) {
+        final result = _handleRosterItem(item);
+
+        if (result.removed != null) removed.add(result.removed!);
+        if (result.modified != null) modified.add(result.modified!);
+        if (result.added != null) added.add(result.added!);
+      }
+
+      await _commitRoster(
+        _currentVersion,
+        removed,
+        modified,
+        added,
+      );
+    });
+  }
+
+  @visibleForTesting
+  List<XmppRosterItem> getRosterItems() => _currentRoster!;
+}
+
+@visibleForTesting
+class TestingRosterStateManager extends BaseRosterStateManager {
+  TestingRosterStateManager(
+    this.initialRosterVersion,
+    this.initialRoster,
+  );
+  final String? initialRosterVersion;
+  final List<XmppRosterItem> initialRoster;
+  int loadCount = 0;
+
+  @override
+  Future<RosterCacheLoadResult> loadRosterCache() async {
+    loadCount++;
+    return RosterCacheLoadResult(
+      initialRosterVersion,
+      initialRoster,
+    );
+  }
+
+  @override
+  Future<void> commitRoster(String? version, List<String> removed, List<XmppRosterItem> modified, List<XmppRosterItem> added) async {}
+}

packages/moxxmpp/lib/src/socket.dart

@@ -5,13 +5,17 @@ abstract class XmppSocketEvent {}
 
 /// Triggered by the socket when an error occurs.
 class XmppSocketErrorEvent extends XmppSocketEvent {
-
   XmppSocketErrorEvent(this.error);
   final Object error;
 }
 
 /// Triggered when the socket is closed
-class XmppSocketClosureEvent extends XmppSocketEvent {}
+class XmppSocketClosureEvent extends XmppSocketEvent {
+  XmppSocketClosureEvent(this.expected);
+
+  /// Indicate that the socket did not close unexpectedly.
+  final bool expected;
+}
 
 /// This class is the base for a socket that XmppConnection can use.
 abstract class BaseSocketWrapper {

packages/moxxmpp/lib/src/stringxml.dart

@@ -129,6 +129,12 @@ class XMLNode {
     }).toList();
   }
   
+  List<XMLNode> findTagsByXmlns(String xmlns) {
+    return children
+      .where((element) => element.attributes['xmlns'] == xmlns)
+      .toList();
+  }
+  
   /// Returns the inner text of the node. If none is set, returns the "".
   String innerText() {
     return text ?? '';

packages/moxxmpp/lib/src/xeps/xep_0030/xep_0030.dart

@@ -289,7 +289,7 @@ class DiscoManager extends XmppManagerBase {
   }
   
   /// Sends a disco info query to the (full) jid [entity], optionally with node=[node].
-  Future<Result<DiscoError, DiscoInfo>> discoInfoQuery(String entity, { String? node}) async {
+  Future<Result<DiscoError, DiscoInfo>> discoInfoQuery(String entity, { String? node, bool shouldEncrypt = true }) async {
     final cacheKey = DiscoCacheKey(entity, node);
     DiscoInfo? info;
     Completer<Result<DiscoError, DiscoInfo>>? completer;
@@ -316,6 +316,7 @@ class DiscoManager extends XmppManagerBase {
 
     final stanza = await getAttributes().sendStanza(
       buildDiscoInfoQueryStanza(entity, node),
+      encrypted: !shouldEncrypt,
     );
     final query = stanza.firstTag('query');
     if (query == null) {
@@ -359,9 +360,12 @@ class DiscoManager extends XmppManagerBase {
   }
 
   /// Sends a disco items query to the (full) jid [entity], optionally with node=[node].
-  Future<Result<DiscoError, List<DiscoItem>>> discoItemsQuery(String entity, { String? node }) async {
+  Future<Result<DiscoError, List<DiscoItem>>> discoItemsQuery(String entity, { String? node, bool shouldEncrypt = true }) async {
     final stanza = await getAttributes()
-      .sendStanza(buildDiscoItemsQueryStanza(entity, node: node)) as Stanza;
+      .sendStanza(
+        buildDiscoItemsQueryStanza(entity, node: node),
+        encrypted: !shouldEncrypt,
+      ) as Stanza;
 
     final query = stanza.firstTag('query');
     if (query == null) return Result(InvalidResponseDiscoError());

packages/moxxmpp/lib/src/xeps/xep_0054.dart

@@ -7,15 +7,20 @@ import 'package:moxxmpp/src/managers/namespaces.dart';
 import 'package:moxxmpp/src/namespaces.dart';
 import 'package:moxxmpp/src/stanza.dart';
 import 'package:moxxmpp/src/stringxml.dart';
+import 'package:moxxmpp/src/types/result.dart';
+
+abstract class VCardError {}
+
+class UnknownVCardError extends VCardError {}
+
+class InvalidVCardError extends VCardError {}
 
 class VCardPhoto {
-
   const VCardPhoto({ this.binval });
   final String? binval;
 }
 
 class VCard {
-
   const VCard({ this.nickname, this.url, this.photo });
   final String? nickname;
   final String? url;
@@ -23,7 +28,6 @@ class VCard {
 }
 
 class VCardManager extends XmppManagerBase {
-
   VCardManager() : _lastHash = {}, super();
   final Map<String, String> _lastHash;
   
@@ -59,12 +63,18 @@ class VCardManager extends XmppManagerBase {
     final lastHash = _lastHash[from];
     if (lastHash != hash) {
       _lastHash[from] = hash;
-      final vcard = await requestVCard(from);
+      final vcardResult = await requestVCard(from);
 
-      if (vcard != null) {
-        final binval = vcard.photo?.binval;
+      if (vcardResult.isType<VCard>()) {
+        final binval = vcardResult.get<VCard>().photo?.binval;
         if (binval != null) {
-          getAttributes().sendEvent(AvatarUpdatedEvent(jid: from, base64: binval, hash: hash));
+          getAttributes().sendEvent(
+            AvatarUpdatedEvent(
+              jid: from,
+              base64: binval,
+              hash: hash,
+            ),
+          );
         } else {
           logger.warning('No avatar data found');
         }
@@ -95,7 +105,7 @@ class VCardManager extends XmppManagerBase {
     );
   }
   
-  Future<VCard?> requestVCard(String jid) async {
+  Future<Result<VCardError, VCard>> requestVCard(String jid) async {
     final result = await getAttributes().sendStanza(
       Stanza.iq(
         to: jid,
@@ -107,12 +117,13 @@ class VCardManager extends XmppManagerBase {
           )
         ],
       ),
+      encrypted: true,
     );
 
-    if (result.attributes['type'] != 'result') return null;
+    if (result.attributes['type'] != 'result') return Result(UnknownVCardError());
     final vcard = result.firstTag('vCard', xmlns: vCardTempXmlns);
-    if (vcard == null) return null;
+    if (vcard == null) return Result(UnknownVCardError());
     
-    return _parseVCard(vcard);
+    return Result(_parseVCard(vcard));
   } 
 }

packages/moxxmpp/lib/src/xeps/xep_0060/xep_0060.dart

@@ -16,7 +16,6 @@ import 'package:moxxmpp/src/xeps/xep_0060/errors.dart';
 import 'package:moxxmpp/src/xeps/xep_0060/helpers.dart';
 
 class PubSubPublishOptions {
-
   const PubSubPublishOptions({
     this.accessModel,
     this.maxItems,
@@ -60,7 +59,6 @@ class PubSubPublishOptions {
 }
 
 class PubSubItem {
-
   const PubSubItem({ required this.id, required this.node, required this.payload });
   final String id;
   final String node;

packages/moxxmpp/lib/src/xeps/xep_0084.dart

@@ -3,21 +3,24 @@ import 'package:moxxmpp/src/managers/base.dart';
 import 'package:moxxmpp/src/managers/namespaces.dart';
 import 'package:moxxmpp/src/namespaces.dart';
 import 'package:moxxmpp/src/stringxml.dart';
+import 'package:moxxmpp/src/types/result.dart';
 import 'package:moxxmpp/src/xeps/xep_0030/errors.dart';
 import 'package:moxxmpp/src/xeps/xep_0030/types.dart';
 import 'package:moxxmpp/src/xeps/xep_0030/xep_0030.dart';
 import 'package:moxxmpp/src/xeps/xep_0060/errors.dart';
 import 'package:moxxmpp/src/xeps/xep_0060/xep_0060.dart';
 
-class UserAvatar {
+abstract class AvatarError {}
 
+class UnknownAvatarError extends AvatarError {}
+
+class UserAvatar {
   const UserAvatar({ required this.base64, required this.hash });
   final String base64;
   final String hash;
 }
 
 class UserAvatarMetadata {
-
   const UserAvatarMetadata(
     this.id,
     this.length,
@@ -49,6 +52,14 @@ class UserAvatarManager extends XmppManagerBase {
   @override
   Future<void> onXmppEvent(XmppEvent event) async {
     if (event is PubSubNotificationEvent) {
+      if (event.item.node != userAvatarDataXmlns) return;
+
+      if (event.item.payload.tag != 'data' ||
+          event.item.payload.attributes['xmlns'] != userAvatarDataXmlns) {
+        logger.warning('Received avatar update from ${event.from} but the payload is invalid. Ignoring...');
+        return;
+      }
+
       getAttributes().sendEvent(
         AvatarUpdatedEvent(
           jid: event.from,
@@ -62,30 +73,30 @@ class UserAvatarManager extends XmppManagerBase {
   // TODO(PapaTutuWawa): Check for PEP support
   @override
   Future<bool> isSupported() async => true;
-  
+
   /// Requests the avatar from [jid]. Returns the avatar data if the request was
   /// successful. Null otherwise
-  // TODO(Unknown): Migrate to Resultsv2
-  Future<UserAvatar?> getUserAvatar(String jid) async {
+  Future<Result<AvatarError, UserAvatar>> getUserAvatar(String jid) async {
     final pubsub = _getPubSubManager();
     final resultsRaw = await pubsub.getItems(jid, userAvatarDataXmlns);
-    if (resultsRaw.isType<PubSubError>()) return null;
+    if (resultsRaw.isType<PubSubError>()) return Result(UnknownAvatarError());
 
     final results = resultsRaw.get<List<PubSubItem>>();
-    if (results.isEmpty) return null;
+    if (results.isEmpty) return Result(UnknownAvatarError());
 
     final item = results[0];
-    return UserAvatar(
-      base64: item.payload.innerText(),
-      hash: item.id,
+    return Result(
+      UserAvatar(
+        base64: item.payload.innerText(),
+        hash: item.id,
+      ),
     );
   }
 
   /// Publish the avatar data, [base64], on the pubsub node using [hash] as
   /// the item id. [hash] must be the SHA-1 hash of the image data, while
   /// [base64] must be the base64-encoded version of the image data.
-  // TODO(Unknown): Migrate to Resultsv2
-  Future<bool> publishUserAvatar(String base64, String hash, bool public) async {
+  Future<Result<AvatarError, bool>> publishUserAvatar(String base64, String hash, bool public) async {
     final pubsub = _getPubSubManager();
     final result = await pubsub.publish(
       getAttributes().getFullJID().toBare().toString(),
@@ -101,14 +112,15 @@ class UserAvatarManager extends XmppManagerBase {
       ),
     );
 
-    return !result.isType<PubSubError>();
+    if (result.isType<PubSubError>()) return Result(UnknownAvatarError());
+    
+    return const Result(true);
   }
 
   /// Publish avatar metadata [metadata] to the User Avatar's metadata node. If [public]
   /// is true, then the node will be set to an 'open' access model. If [public] is false,
   /// then the node will be set to an 'roster' access model.
-  // TODO(Unknown): Migrate to Resultsv2
-  Future<bool> publishUserAvatarMetadata(UserAvatarMetadata metadata, bool public) async {
+  Future<Result<AvatarError, bool>> publishUserAvatarMetadata(UserAvatarMetadata metadata, bool public) async {
     final pubsub = _getPubSubManager();
     final result = await pubsub.publish(
       getAttributes().getFullJID().toBare().toString(),
@@ -135,39 +147,37 @@ class UserAvatarManager extends XmppManagerBase {
       ),
     );
 
-    return result.isType<PubSubError>();
+    if (result.isType<PubSubError>()) return Result(UnknownAvatarError());
+    return const Result(true);
   }
   
   /// Subscribe the data and metadata node of [jid].
-  // TODO(Unknown): Migrate to Resultsv2
-  Future<bool> subscribe(String jid) async {
+  Future<Result<AvatarError, bool>> subscribe(String jid) async {
     await _getPubSubManager().subscribe(jid, userAvatarDataXmlns);
     await _getPubSubManager().subscribe(jid, userAvatarMetadataXmlns);
 
-    return true;
+    return const Result(true);
   }
 
   /// Unsubscribe the data and metadata node of [jid].
-  // TODO(Unknown): Migrate to Resultsv2
-  Future<bool> unsubscribe(String jid) async {
+  Future<Result<AvatarError, bool>> unsubscribe(String jid) async {
     await _getPubSubManager().unsubscribe(jid, userAvatarDataXmlns);
     await _getPubSubManager().subscribe(jid, userAvatarMetadataXmlns);
 
-    return true;
+    return const Result(true);
   }
 
   /// Returns the PubSub Id of an avatar after doing a disco#items query.
   /// Note that this assumes that there is only one (1) item published on
   /// the node.
-  // TODO(Unknown): Migrate to Resultsv2
-  Future<String?> getAvatarId(String jid) async {
+  Future<Result<AvatarError, String>> getAvatarId(String jid) async {
     final disco = getAttributes().getManagerById(discoManager)! as DiscoManager;
-    final response = await disco.discoItemsQuery(jid, node: userAvatarDataXmlns);
-    if (response.isType<DiscoError>()) return null;
+    final response = await disco.discoItemsQuery(jid, node: userAvatarDataXmlns, shouldEncrypt: false);
+    if (response.isType<DiscoError>()) return Result(UnknownAvatarError());
 
     final items = response.get<List<DiscoItem>>();
-    if (items.isEmpty) return null;
+    if (items.isEmpty) return Result(UnknownAvatarError());
 
-    return items.first.name;
+    return Result(items.first.name);
   }
 }

packages/moxxmpp/lib/src/xeps/xep_0198/xep_0198.dart

@@ -142,7 +142,7 @@ class StreamManagementManager extends XmppManagerBase {
   ];
 
   @override
-  List<StanzaHandler> getIncomingStanzaHandlers() => [
+  List<StanzaHandler> getIncomingPreStanzaHandlers() => [
     StanzaHandler(
       callback: _onServerStanzaReceived,
       priority: 9999,
@@ -185,9 +185,18 @@ class StreamManagementManager extends XmppManagerBase {
       _disableStreamManagement();
       _streamResumed = false;
     } else if (event is ConnectionStateChangedEvent) {
-      if (event.state == XmppConnectionState.connected) {
+      switch (event.state) {
+      case XmppConnectionState.connected:
         // Push out all pending stanzas
         await onStreamResumed(0);
+        break;
+      case XmppConnectionState.error:
+      case XmppConnectionState.notConnected:
+        _stopAckTimer();
+        break;
+      case XmppConnectionState.connecting:
+        // NOOP
+        break;
       }
     }
   }

packages/moxxmpp/lib/src/xeps/xep_0203.dart

@@ -8,14 +8,12 @@ import 'package:moxxmpp/src/stanza.dart';
 
 @immutable
 class DelayedDelivery {
-
   const DelayedDelivery(this.from, this.timestamp);
   final DateTime timestamp;
   final String from;
 }
 
 class DelayedDeliveryManager extends XmppManagerBase {
-
   @override
   String getId() => delayedDeliveryManager;
 

packages/moxxmpp/lib/src/xeps/xep_0280.dart

@@ -12,12 +12,18 @@ import 'package:moxxmpp/src/stringxml.dart';
 import 'package:moxxmpp/src/xeps/xep_0030/xep_0030.dart';
 import 'package:moxxmpp/src/xeps/xep_0297.dart';
 
+/// This manager class implements support for XEP-0280.
 class CarbonsManager extends XmppManagerBase {
+  CarbonsManager() : super();
 
-  CarbonsManager() : _isEnabled = false, _supported = false, _gotSupported = false, super();
-  bool _isEnabled;
-  bool _supported;
-  bool _gotSupported;
+  /// Indicates that message carbons are enabled.
+  bool _isEnabled = false;
+
+  /// Indicates that the server supports message carbons.
+  bool _supported = false;
+
+  /// Indicates that we know that [CarbonsManager._supported] is accurate.
+  bool _gotSupported = false;
   
   @override
   String getId() => carbonsManager;
@@ -26,13 +32,12 @@ class CarbonsManager extends XmppManagerBase {
   String getName() => 'CarbonsManager';
 
   @override
-  List<StanzaHandler> getIncomingStanzaHandlers() => [
+  List<StanzaHandler> getIncomingPreStanzaHandlers() => [
     StanzaHandler(
       stanzaTag: 'message',
       tagName: 'received',
       tagXmlns: carbonsXmlns,
       callback: _onMessageReceived,
-      // Before all managers the message manager depends on
       priority: -98,
     ),
     StanzaHandler(
@@ -40,7 +45,6 @@ class CarbonsManager extends XmppManagerBase {
       tagName: 'sent',
       tagXmlns: carbonsXmlns,
       callback: _onMessageSent,
-      // Before all managers the message manager depends on
       priority: -98,
     )
   ];
@@ -104,10 +108,15 @@ class CarbonsManager extends XmppManagerBase {
       stanza: carbon,
     );
   }
-  
+
+  /// Send a request to the server, asking it to enable Message Carbons.
+  ///
+  /// Returns true if carbons were enabled. False, if not.
   Future<bool> enableCarbons() async {
-    final result = await getAttributes().sendStanza(
+    final attrs = getAttributes();
+    final result = await attrs.sendStanza(
       Stanza.iq(
+        to: attrs.getFullJID().toBare().toString(),
         type: 'set',
         children: [
           XMLNode.xmlns(
@@ -132,6 +141,9 @@ class CarbonsManager extends XmppManagerBase {
     return true;
   }
 
+  /// Send a request to the server, asking it to disable Message Carbons.
+  ///
+  /// Returns true if carbons were disabled. False, if not.
   Future<bool> disableCarbons() async {
     final result = await getAttributes().sendStanza(
       Stanza.iq(
@@ -159,12 +171,22 @@ class CarbonsManager extends XmppManagerBase {
     return true;
   }
 
+  /// True if Message Carbons are enabled. False, if not.
+  bool get isEnabled => _isEnabled;
+  
   @visibleForTesting
   void forceEnable() {
     _isEnabled = true;
   }
-  
+
+  /// Checks if a carbon sent by [senderJid] is valid to prevent vulnerabilities like
+  /// the ones listed at https://xmpp.org/extensions/xep-0280.html#security.
+  ///
+  /// Returns true if the carbon is valid. Returns false if not.
   bool isCarbonValid(JID senderJid) {
-    return _isEnabled && senderJid == getAttributes().getConnectionSettings().jid.toBare();
+    return _isEnabled && getAttributes().getFullJID().bareCompare(
+      senderJid,
+      ensureBare: true,
+    );
   }
 }

packages/moxxmpp/lib/src/xeps/xep_0334.dart

@@ -8,8 +8,18 @@ enum MessageProcessingHint {
   store,
 }
 
-/// NOTE: We do not define a function for turning a Message Processing Hint element into
-///       an enum value since the elements do not concern us as a client.
+MessageProcessingHint messageProcessingHintFromXml(XMLNode element) {
+  switch (element.tag) {
+    case 'no-permanent-store': return MessageProcessingHint.noPermanentStore;
+    case 'no-store': return MessageProcessingHint.noStore;
+    case 'no-copy': return MessageProcessingHint.noCopies;
+    case 'store': return MessageProcessingHint.store;
+  }
+    
+  assert(false, 'Invalid Message Processing Hint: ${element.tag}');
+  return MessageProcessingHint.noStore;
+}
+
 extension XmlExtension on MessageProcessingHint {
   XMLNode toXml() {
     String tag;

packages/moxxmpp/lib/src/xeps/xep_0384/errors.dart

@@ -7,3 +7,5 @@ class InvalidAffixElementsException with Exception {}
 class OmemoNotSupportedForContactException extends OmemoError {}
 
 class EncryptionFailedException with Exception {}
+
+class InvalidEnvelopePayloadException with Exception {}

packages/moxxmpp/lib/src/xeps/xep_0384/xep_0384.dart

@@ -1,8 +1,6 @@
 import 'dart:async';
-import 'dart:collection';
 import 'dart:convert';
 import 'package:meta/meta.dart';
-import 'package:moxlib/moxlib.dart';
 import 'package:moxxmpp/src/events.dart';
 import 'package:moxxmpp/src/jid.dart';
 import 'package:moxxmpp/src/managers/base.dart';
@@ -18,6 +16,7 @@ import 'package:moxxmpp/src/xeps/xep_0030/types.dart';
 import 'package:moxxmpp/src/xeps/xep_0030/xep_0030.dart';
 import 'package:moxxmpp/src/xeps/xep_0060/errors.dart';
 import 'package:moxxmpp/src/xeps/xep_0060/xep_0060.dart';
+import 'package:moxxmpp/src/xeps/xep_0280.dart';
 import 'package:moxxmpp/src/xeps/xep_0334.dart';
 import 'package:moxxmpp/src/xeps/xep_0380.dart';
 import 'package:moxxmpp/src/xeps/xep_0384/crypto.dart';
@@ -25,7 +24,7 @@ import 'package:moxxmpp/src/xeps/xep_0384/errors.dart';
 import 'package:moxxmpp/src/xeps/xep_0384/helpers.dart';
 import 'package:moxxmpp/src/xeps/xep_0384/types.dart';
 import 'package:omemo_dart/omemo_dart.dart';
-import 'package:synchronized/synchronized.dart';
+import 'package:xml/xml.dart';
 
 const _doNotEncryptList = [
   // XEP-0033
@@ -43,17 +42,7 @@ const _doNotEncryptList = [
   DoNotEncrypt('stanza-id', stableIdXmlns),
 ];
 
-abstract class OmemoManager extends XmppManagerBase {
-  OmemoManager() : _handlerLock = Lock(), _handlerFutures = {}, super();
-
-  final Lock _handlerLock;
-  final Map<JID, Queue<Completer<void>>> _handlerFutures;
-
-  final Map<JID, List<int>> _deviceMap = {};
-
-  // Mapping whether we already tried to subscribe to the JID's devices node
-  final Map<JID, bool> _subscriptionMap = {};
-  
+abstract class BaseOmemoManager extends XmppManagerBase {
   @override
   String getId() => omemoManager;
 
@@ -65,27 +54,24 @@ abstract class OmemoManager extends XmppManagerBase {
   Future<bool> isSupported() async => true;
 
   @override
-  List<StanzaHandler> getIncomingStanzaHandlers() => [
+  List<StanzaHandler> getIncomingPreStanzaHandlers() => [
     StanzaHandler(
       stanzaTag: 'iq',
       tagXmlns: omemoXmlns,
       tagName: 'encrypted',
       callback: _onIncomingStanza,
-      priority: 9999,
     ),
     StanzaHandler(
       stanzaTag: 'presence',
       tagXmlns: omemoXmlns,
       tagName: 'encrypted',
       callback: _onIncomingStanza,
-      priority: 9999,
     ),
     StanzaHandler(
       stanzaTag: 'message',
       tagXmlns: omemoXmlns,
       tagName: 'encrypted',
       callback: _onIncomingStanza,
-      priority: -98,
     ),
   ];
 
@@ -127,60 +113,31 @@ abstract class OmemoManager extends XmppManagerBase {
       } else {
         // Someone published to their device list node
         logger.finest('Got devices $ids');
-        _deviceMap[jid] = ids;
       }
 
+      // Tell the OmemoManager
+      (await getOmemoManager())
+        .onDeviceListUpdate(jid.toString(), ids);
+
       // Generate an event
       getAttributes().sendEvent(OmemoDeviceListUpdatedEvent(jid, ids));
     }
   }
-  
+
   @visibleForOverriding
-  Future<OmemoSessionManager> getSessionManager();
+  Future<OmemoManager> getOmemoManager();
 
-  /// Wrapper around using getSessionManager and then calling encryptToJids on it.
-  Future<EncryptionResult> _encryptToJids(List<String> jids, String? plaintext, { List<OmemoBundle>? newSessions }) async {
-    final session = await getSessionManager();
-    return session.encryptToJids(jids, plaintext, newSessions: newSessions);
-  }
-
-  /// Wrapper around using getSessionManager and then calling encryptToJids on it.
-  Future<String?> _decryptMessage(List<int>? ciphertext, String senderJid, int senderDeviceId, List<EncryptedKey> keys, int sendTimestamp) async {
-    final session = await getSessionManager();
-    return session.decryptMessage(
-      ciphertext,
-      senderJid,
-      senderDeviceId,
-      keys,
-      sendTimestamp,
-    );
-  }
   
   /// Wrapper around using getSessionManager and then calling getDeviceId on it.
-  Future<int> _getDeviceId() async {
-    final session = await getSessionManager();
-    return session.getDeviceId();
-  }
+  Future<int> _getDeviceId() async => (await getOmemoManager()).getDeviceId();
 
   /// Wrapper around using getSessionManager and then calling getDeviceId on it.
   Future<OmemoBundle> _getDeviceBundle() async {
-    final session = await getSessionManager();
-    return session.getDeviceBundle();
+    final om = await getOmemoManager();
+    final device = await om.getDevice();
+    return device.toBundle();
   }
 
-  /// Wrapper around using getSessionManager and then calling isRatchetAcknowledged on it.
-  Future<bool> _isRatchetAcknowledged(String jid, int deviceId) async {
-    final session = await getSessionManager();
-    return session.isRatchetAcknowledged(jid, deviceId);
-  }
-
-  /// Wrapper around checking if [jid] appears in the session manager's device map.
-  Future<bool> _hasSessionWith(String jid) async {
-    final session = await getSessionManager();
-    final deviceMap = await session.getDeviceMap();
-    return deviceMap.containsKey(jid);
-  }
-  
   /// Determines what child elements of a stanza should be encrypted. If shouldEncrypt
   /// returns true for [element], then [element] will be encrypted. If shouldEncrypt
   /// returns false, then [element] won't be encrypted.
@@ -205,56 +162,51 @@ abstract class OmemoManager extends XmppManagerBase {
   /// an attached payload, if [children] is not null, or an empty OMEMO message if
   /// [children] is null. This function takes care of creating the affix elements as
   /// specified by both XEP-0420 and XEP-0384.
-  /// [jids] is the list of JIDs the payload should be encrypted for.
-  Future<XMLNode> _encryptChildren(List<XMLNode>? children, List<String> jids, String toJid, List<OmemoBundle> newSessions) async {
-    XMLNode? payload;
-    if (children != null) {
-      payload = XMLNode.xmlns(
-        tag: 'envelope',
-        xmlns: sceXmlns,
-        children: [
-          XMLNode(
-            tag: 'content',
-            children: children,
-          ),
+  /// [toJid] is the list of JIDs the payload should be encrypted for.
+  String _buildEnvelope(List<XMLNode> children, String toJid) {
+    final payload = XMLNode.xmlns(
+      tag: 'envelope',
+      xmlns: sceXmlns,
+      children: [
+        XMLNode(
+          tag: 'content',
+          children: children,
+        ),
 
-          XMLNode(
-            tag: 'rpad',
-            text: generateRpad(),
-          ),
-          XMLNode(
-            tag: 'to',
-            attributes: <String, String>{
-              'jid': toJid,
-            },
-          ),
-          XMLNode(
-            tag: 'from',
-            attributes: <String, String>{
-              'jid': getAttributes().getFullJID().toString(),
-            },
-          ),
-          /*
-          XMLNode(
-            tag: 'time',
-            // TODO(Unknown): Implement
-            attributes: <String, String>{
-              'stamp': '',
-            },
-          ),
-          */
-        ],
-      );
-    }
-
-    final encryptedEnvelope = await _encryptToJids(
-      jids,
-      payload?.toXml(),
-      newSessions: newSessions,
+        XMLNode(
+          tag: 'rpad',
+          text: generateRpad(),
+        ),
+        XMLNode(
+          tag: 'to',
+          attributes: <String, String>{
+            'jid': toJid,
+          },
+        ),
+        XMLNode(
+          tag: 'from',
+          attributes: <String, String>{
+            'jid': getAttributes().getFullJID().toString(),
+          },
+        ),
+        /*
+        XMLNode(
+          tag: 'time',
+          // TODO(Unknown): Implement
+          attributes: <String, String>{
+            'stamp': '',
+          },
+        ),
+        */
+      ],
     );
 
+    return payload.toXml();
+  }
+
+  XMLNode _buildEncryptedElement(EncryptionResult result, String recipientJid, int deviceId) {
     final keyElements = <String, List<XMLNode>>{};
-    for (final key in encryptedEnvelope.encryptedKeys) {
+    for (final key in result.encryptedKeys) {
       final keyElement = XMLNode(
         tag: 'key',
         attributes: <String, String>{
@@ -282,11 +234,11 @@ abstract class OmemoManager extends XmppManagerBase {
     }).toList();
 
     var payloadElement = <XMLNode>[];
-    if (payload != null) {
+    if (result.ciphertext != null) {
       payloadElement = [
         XMLNode(
           tag: 'payload',
-          text: base64.encode(encryptedEnvelope.ciphertext!),
+          text: base64.encode(result.ciphertext!),
         ),
       ];
     }
@@ -299,7 +251,7 @@ abstract class OmemoManager extends XmppManagerBase {
         XMLNode(
           tag: 'header',
           attributes: <String, String>{
-            'sid': (await _getDeviceId()).toString(),
+            'sid': deviceId.toString(),
           },
           children: keysElements,
         ),
@@ -307,136 +259,18 @@ abstract class OmemoManager extends XmppManagerBase {
     );
   }
 
-  /// A logging wrapper around acking the ratchet with [jid] with identifier [deviceId].
-  Future<void> _ackRatchet(String jid, int deviceId) async {
-    logger.finest('Acking ratchet $jid:$deviceId');
-    final session = await getSessionManager();
-    await session.ratchetAcknowledged(jid, deviceId);
-  }
-
-  /// Figure out if new sessions need to be built. [toJid] is the JID of the entity we
-  /// want to send a message to. [children] refers to the unencrypted children of the
-  /// message. They are required to be passed because shouldIgnoreUnackedRatchets is
-  /// called here.
-  ///
-  /// Either returns a list of bundles we "need" to build a session with or an OmemoError.
-  Future<Result<OmemoError, List<OmemoBundle>>> _findNewSessions(JID toJid, List<XMLNode> children) async {
-    final ownJid = getAttributes().getFullJID().toBare();
-    final session = await getSessionManager();
-    final ownId = await session.getDeviceId();
-
-    // Ignore our own device if it is the only published device on our devices node
-    if (toJid.toBare() == ownJid) {
-      final deviceList = await getDeviceList(ownJid);
-      if (deviceList.isType<List<int>>()) {
-        final devices = deviceList.get<List<int>>();
-        if (devices.length == 1 && devices.first == ownId) {
-          return const Result(<OmemoBundle>[]);
-        }
-      }
-    }
-
-    final newSessions = List<OmemoBundle>.empty(growable: true);
-    final sessionAvailable = await _hasSessionWith(toJid.toString());   
-    if (!sessionAvailable) {
-      logger.finest('No session for $toJid. Retrieving bundles to build a new session.');
-      final result = await retrieveDeviceBundles(toJid);
-      if (result.isType<List<OmemoBundle>>()) {
-        final bundles = result.get<List<OmemoBundle>>();
-
-        if (ownJid == toJid) {
-          logger.finest('Requesting bundles for own JID. Ignoring current device');
-          newSessions.addAll(bundles.where((bundle) => bundle.id != ownId));
-        } else {
-          newSessions.addAll(bundles);
-        }
-      } else {
-        logger.warning('Failed to retrieve device bundles for $toJid');
-        return Result(OmemoNotSupportedForContactException());
-      }
-
-      if (!_subscriptionMap.containsKey(toJid)) {
-        await subscribeToDeviceList(toJid);
-      }
-    } else {
-      final toBare = toJid.toBare();
-      final ratchetSessions = (await session.getDeviceMap())[toBare.toString()]!;
-      final deviceMapRaw = await getDeviceList(toBare);
-      if (!_subscriptionMap.containsKey(toBare)) {
-        unawaited(subscribeToDeviceList(toBare));
-      }
-
-      if (deviceMapRaw.isType<OmemoError>()) {
-        logger.warning('Failed to get device list');
-        return Result(UnknownOmemoError());
-      }
-
-      final deviceList = deviceMapRaw.get<List<int>>();
-      for (final id in deviceList) {
-        // We already have a session with that device
-        if (ratchetSessions.contains(id)) continue;
-
-        // Ignore requests for our own device.
-        if (toJid == ownJid && id == ownId) {
-          logger.finest('Attempted to request bundle for our own device $id, which is the current device. Skipping request...');
-          continue;
-        }
-
-        logger.finest('Retrieving bundle for $toJid:$id');
-        final bundle = await retrieveDeviceBundle(toJid, id);
-        if (bundle.isType<OmemoBundle>()) {
-          newSessions.add(bundle.get<OmemoBundle>());
-        } else {
-          logger.warning('Failed to retrieve bundle for $toJid:$id');
-        }
-      }
-    }
-    
-    return Result(newSessions);
-  }
-
-  /// Sends an empty Omemo message to [toJid].
-  ///
-  /// If [findNewSessions] is true, then
-  /// new devices will be looked for first before sending the message. This means that
-  /// the new sessions will be included in the empty Omemo message. If false, then no
-  /// new sessions will be looked for before encrypting.
-  ///
-  /// [calledFromCriticalSection] MUST NOT be used from outside the manager. If true, then
-  /// sendEmptyMessage will not attempt to enter the critical section guarding the
-  /// encryption and decryption. If false, then the critical section will be entered before
-  /// encryption and left after sending the message.
-  Future<void> sendEmptyMessage(JID toJid, {
-    bool findNewSessions = false,
-    @protected
-    bool calledFromCriticalSection = false,
-  }) async {
-    if (!calledFromCriticalSection) {
-      final completer = await _handlerEntry(toJid);
-      if (completer != null) {
-        await completer.future;
-      }
-    }
-
-    var newSessions = <OmemoBundle>[];
-    if (findNewSessions) {
-      final result = await _findNewSessions(toJid, <XMLNode>[]);
-      if (!result.isType<OmemoError>()) newSessions = result.get<List<OmemoBundle>>();
-    }
-
-    final empty = await _encryptChildren(
-      null,
-      [toJid.toString()],
-      toJid.toString(),
-      newSessions,
-    );
-
+  /// For usage with omemo_dart's OmemoManager.
+  Future<void> sendEmptyMessageImpl(EncryptionResult result, String toJid) async {
     await getAttributes().sendStanza(
       Stanza.message(
-        to: toJid.toString(),
+        to: toJid,
         type: 'chat',
         children: [
-          empty,
+          _buildEncryptedElement(
+            result,
+            toJid,
+            await _getDeviceId(),
+          ),
 
           // Add a storage hint in case this is a message
           // Taken from the example at
@@ -447,10 +281,28 @@ abstract class OmemoManager extends XmppManagerBase {
       awaitable: false,
       encrypted: true,
     );
+  }
 
-    if (!calledFromCriticalSection) {
-      await _handlerExit(toJid);
-    }
+  /// Send a heartbeat message to [jid].
+  Future<void> sendOmemoHeartbeat(String jid) async {
+    final om = await getOmemoManager();
+    await om.sendOmemoHeartbeat(jid);
+  }
+  
+  /// For usage with omemo_dart's OmemoManager
+  Future<List<int>?> fetchDeviceList(String jid) async {
+    final result = await getDeviceList(JID.fromString(jid));
+    if (result.isType<OmemoError>()) return null;
+
+    return result.get<List<int>>();
+  }
+
+  /// For usage with omemo_dart's OmemoManager
+  Future<OmemoBundle?> fetchDeviceBundle(String jid, int id) async {
+    final result = await retrieveDeviceBundle(JID.fromString(jid), id);
+    if (result.isType<OmemoError>()) return null;
+
+    return result.get<OmemoBundle>();
   }
   
   Future<StanzaHandlerData> _onOutgoingStanza(Stanza stanza, StanzaHandlerData state) async {
@@ -461,6 +313,7 @@ abstract class OmemoManager extends XmppManagerBase {
 
     if (stanza.to == null) {
       // We cannot encrypt in this case.
+      logger.finest('Not encrypting since stanza.to is null');
       return state;
     }
 
@@ -471,34 +324,7 @@ abstract class OmemoManager extends XmppManagerBase {
     } else {
       logger.finest('shouldEncryptStanza returned true for message to $toJid.');
     }
-    
-    final completer = await _handlerEntry(toJid);
-    if (completer != null) {
-      await completer.future;
-    }
 
-    final newSessions = List<OmemoBundle>.empty(growable: true);
-    // Try to find new sessions for [toJid].
-    final resultToJid = await _findNewSessions(toJid, stanza.children);
-    if (resultToJid.isType<List<OmemoBundle>>()) {
-      newSessions.addAll(resultToJid.get<List<OmemoBundle>>());
-    } else {
-      if (resultToJid.isType<OmemoNotSupportedForContactException>()) {
-        await _handlerExit(toJid);
-        return state.copyWith(
-          cancel: true,
-          cancelReason: resultToJid.get<OmemoNotSupportedForContactException>(),
-        );
-      }
-    }
-
-    // Try to find new sessions for our own Jid.
-    final ownJid = getAttributes().getFullJID().toBare();
-    final resultOwnJid = await _findNewSessions(ownJid, stanza.children);
-    if (resultOwnJid.isType<List<OmemoBundle>>()) {
-      newSessions.addAll(resultOwnJid.get<List<OmemoBundle>>());
-    }
-    
     final toEncrypt = List<XMLNode>.empty(growable: true);
     final children = List<XMLNode>.empty(growable: true);
     for (final child in stanza.children) {
@@ -508,76 +334,56 @@ abstract class OmemoManager extends XmppManagerBase {
         toEncrypt.add(child);
       }
     }
+    
+    logger.finest('Beginning encryption');
+    final carbonsEnabled = getAttributes()
+      .getManagerById<CarbonsManager>(carbonsManager)?.isEnabled ?? false;
+    final om = await getOmemoManager();
+    final result = await om.onOutgoingStanza(
+      OmemoOutgoingStanza(
+        [
+          toJid.toString(),
+          if (carbonsEnabled)
+            getAttributes().getFullJID().toBare().toString(),
+        ],
+        _buildEnvelope(toEncrypt, toJid.toString()),
+      ),
+    );
+    logger.finest('Encryption done');
 
-    final jidsToEncryptFor = <String>[JID.fromString(stanza.to!).toBare().toString()];
-    // Prevent encrypting to self if there is only one device (ours).
-    if (await _hasSessionWith(ownJid.toString())) {
-      jidsToEncryptFor.add(ownJid.toString());
-    }
-
-    try {
-      logger.finest('Encrypting stanza');
-      final encrypted = await _encryptChildren(
-        toEncrypt,
-        jidsToEncryptFor,
-        stanza.to!,
-        newSessions,
-      );
-      logger.finest('Encryption done');
-
-      children.add(encrypted);
-
-      // Only add EME when sending a message
-      if (stanza.tag == 'message') {
-        children.add(buildEmeElement(ExplicitEncryptionType.omemo2));
-      }
-
-      // Add a storage hint in case this is a message
-      // Taken from the example at
-      // https://xmpp.org/extensions/xep-0384.html#message-structure-description.
-      if (stanza.tag == 'message') {
-        children.add(MessageProcessingHint.store.toXml());
-      }
-      
-      await _handlerExit(toJid);
-      return state.copyWith(
-        stanza: state.stanza.copyWith(
-          children: children,
-        ),
-        encrypted: true,
-      );
-    } catch (ex) {
-      logger.severe('Encryption failed! $ex');
-      await _handlerExit(toJid);
+    if (!result.isSuccess(2)) {
+      final other = Map<String, dynamic>.from(state.other);
+      other['encryption_error_jids'] = result.jidEncryptionErrors;
+      other['encryption_error_devices'] = result.deviceEncryptionErrors;
       return state.copyWith(
+        other: other,
         cancel: true,
-        cancelReason: EncryptionFailedException(),
-        other: {
-          ...state.other,
-          'encryption_error': ex,
-        },
       );
     }
-  }
-
-  /// This function returns true if the encryption scheme should ignore unacked ratchets
-  /// and don't try to build a new ratchet even though there are unacked ones.
-  /// The current logic is that chat states with no body ignore the "ack" state of the
-  /// ratchets.
-  ///
-  /// This function may be overriden. By default, the ack status of the ratchet is ignored
-  /// if we're sending a message containing chatstates or chat markers and the message does
-  /// not contain a <body /> element.
-  @visibleForOverriding
-  bool shouldIgnoreUnackedRatchets(List<XMLNode> children) {
-    return listContains(
-      children,
-      (XMLNode child) {
-        return child.attributes['xmlns'] == chatStateXmlns || child.attributes['xmlns'] == chatMarkersXmlns;
-      },
-    ) && !listContains(
-      children,
-      (XMLNode child) => child.tag == 'body',
+    
+    final encrypted = _buildEncryptedElement(
+      result,
+      toJid.toString(),
+      await _getDeviceId(),
+    );
+    children.add(encrypted);
+    
+    // Only add message specific metadata when actually sending a message
+    if (stanza.tag == 'message') {
+      children
+        // Add EME data
+        ..add(buildEmeElement(ExplicitEncryptionType.omemo2))
+        // Add a storage hint in case this is a message
+        // Taken from the example at
+        // https://xmpp.org/extensions/xep-0384.html#message-structure-description.
+        ..add(MessageProcessingHint.store.toXml());
+    }
+    
+    return state.copyWith(
+      stanza: state.stanza.copyWith(
+        children: children,
+      ),
+      encrypted: true,
     );
   }
 
@@ -587,48 +393,12 @@ abstract class OmemoManager extends XmppManagerBase {
   @visibleForOverriding
   Future<bool> shouldEncryptStanza(JID toJid, Stanza stanza);
   
-  /// Wrapper function that attempts to enter the encryption/decryption critical section.
-  /// In case the critical section could be entered, null is returned. If not, then a
-  /// Completer is returned whose future will resolve once the critical section can be
-  /// entered.
-  Future<Completer<void>?> _handlerEntry(JID fromJid) async {
-    return _handlerLock.synchronized(() {
-      if (_handlerFutures.containsKey(fromJid)) {
-        final c = Completer<void>();
-        _handlerFutures[fromJid]!.addLast(c);
-        return c;
-      }
-
-      _handlerFutures[fromJid] = Queue();
-      return null;
-    });
-  }
-
-  /// Wrapper function that exits the critical section.
-  Future<void> _handlerExit(JID fromJid) async {
-    await _handlerLock.synchronized(() {
-      if (_handlerFutures.containsKey(fromJid)) {
-        if (_handlerFutures[fromJid]!.isEmpty) {
-          _handlerFutures.remove(fromJid);
-          return;
-        }
-
-        _handlerFutures[fromJid]!.removeFirst().complete();
-      }
-    });
-  }
-  
   Future<StanzaHandlerData> _onIncomingStanza(Stanza stanza, StanzaHandlerData state) async {
     final encrypted = stanza.firstTag('encrypted', xmlns: omemoXmlns);
     if (encrypted == null) return state;
     if (stanza.from == null) return state;
 
     final fromJid = JID.fromString(stanza.from!).toBare();
-    final completer = await _handlerEntry(fromJid);
-    if (completer != null) {
-      await completer.future;
-    }
-    
     final header = encrypted.firstTag('header')!;
     final payloadElement = encrypted.firstTag('payload');
     final keys = List<EncryptedKey>.empty(growable: true);
@@ -649,118 +419,62 @@ abstract class OmemoManager extends XmppManagerBase {
     final ourJid = getAttributes().getFullJID();
     final sid = int.parse(header.attributes['sid']! as String);
 
-    // Ensure that if we receive a message from a device that we don't know about, we
-    // ensure that _deviceMap is up-to-date.
-    final devices = _deviceMap[fromJid] ?? <int>[];
-    if (!devices.contains(sid)) {
-      await getDeviceList(fromJid);
-    }
-
-    String? decrypted;
-    try {
-      decrypted = await _decryptMessage(
-        payloadElement != null ? base64.decode(payloadElement.innerText()) : null,
+    final om = await getOmemoManager();
+    final result = await om.onIncomingStanza(
+      OmemoIncomingStanza(
         fromJid.toString(),
         sid,
-        keys,
         state.delayedDelivery?.timestamp.millisecondsSinceEpoch ?? DateTime.now().millisecondsSinceEpoch,
-      );
-    } catch (ex) {
-      logger.warning('Error occurred during message decryption: $ex');
+        keys,
+        payloadElement?.innerText(),
+      ),
+    );
 
-      await _handlerExit(fromJid);
-      return state.copyWith(
-        other: {
-          ...state.other,
-          'encryption_error': ex,
-        },
-      );
-    }
-    
-    final isAcked = await _isRatchetAcknowledged(fromJid.toString(), sid);
-    if (!isAcked) {
-      // Unacked ratchet decrypted this message
-      if (decrypted != null) {
-        // The message is not empty, i.e. contains content
-        logger.finest('Received non-empty OMEMO encrypted message for unacked ratchet. Acking with empty OMEMO message.');
-
-        await _ackRatchet(fromJid.toString(), sid);
-        await sendEmptyMessage(fromJid, calledFromCriticalSection: true);
-
-        final envelope = XMLNode.fromString(decrypted);
-        final children = stanza.children.where(
-          (child) => child.tag != 'encrypted' || child.attributes['xmlns'] != omemoXmlns,
-        ).toList()
-          ..addAll(envelope.firstTag('content')!.children);
-
-        final other = Map<String, dynamic>.from(state.other);
-        if (!checkAffixElements(envelope, stanza.from!, ourJid)) {
-          other['encryption_error'] = InvalidAffixElementsException();
-        }
-
-        await _handlerExit(fromJid);
-        return state.copyWith(
-          encrypted: true,
-          stanza: Stanza(
-            to: stanza.to,
-            from: stanza.from,
-            id: stanza.id,
-            type: stanza.type,
-            children: children,
-            tag: stanza.tag,
-            attributes: Map<String, String>.from(stanza.attributes),
-          ),
-          other: other,
-        );
-      } else {
-        logger.info('Received empty OMEMO message for unacked ratchet. Marking $fromJid:$sid as acked');
-        await _ackRatchet(fromJid.toString(), sid);
-
-        final ownId = await (await getSessionManager()).getDeviceId();
-        final kex = keys.any((key) => key.kex && key.rid == ownId);
-        if (kex) {
-          logger.info('Empty OMEMO message contained a kex. Answering.');
-          await sendEmptyMessage(fromJid, calledFromCriticalSection: true);
-        }
-
-        await _handlerExit(fromJid);
-        return state;
-      }
+    final other = Map<String, dynamic>.from(state.other);
+    var children = stanza.children;
+    if (result.error != null) {
+      other['encryption_error'] = result.error;
     } else {
-      // The ratchet that decrypted the message was acked
-      if (decrypted != null) {
-        final envelope = XMLNode.fromString(decrypted);
+      children = stanza.children.where(
+        (child) => child.tag != 'encrypted' || child.attributes['xmlns'] != omemoXmlns,
+      ).toList();
+    }
 
-        final children = stanza.children.where(
-          (child) => child.tag != 'encrypted' || child.attributes['xmlns'] != omemoXmlns,
-        ).toList()
-          ..addAll(envelope.firstTag('content')!.children);
-
-        final other = Map<String, dynamic>.from(state.other);
-        if (!checkAffixElements(envelope, stanza.from!, ourJid)) {
-          other['encryption_error'] = InvalidAffixElementsException();
-        }
-        
-        await _handlerExit(fromJid);
+    if (result.payload != null) {
+      XMLNode envelope;
+      try {
+        envelope = XMLNode.fromString(result.payload!);
+      } on XmlParserException catch (_) {
+        logger.warning('Failed to parse envelope payload: ${result.payload!}');
+        other['encryption_error'] = InvalidEnvelopePayloadException();
         return state.copyWith(
           encrypted: true,
-          stanza: Stanza(
-            to: stanza.to,
-            from: stanza.from,
-            id: stanza.id,
-            type: stanza.type,
-            children: children,
-            tag: stanza.tag,
-            attributes: Map<String, String>.from(stanza.attributes),
-          ),
           other: other,
         );
-      } else {
-        logger.info('Received empty OMEMO message on acked ratchet. Doing nothing');
-        await _handlerExit(fromJid);
-        return state;
+      }
+
+      children.addAll(
+        envelope.firstTag('content')!.children,
+      );
+
+      if (!checkAffixElements(envelope, stanza.from!, ourJid)) {
+        other['encryption_error'] = InvalidAffixElementsException();
       }
     }
+
+    return state.copyWith(
+      encrypted: true,
+      stanza: Stanza(
+        to: stanza.to,
+        from: stanza.from,
+        id: stanza.id,
+        type: stanza.type,
+        children: children,
+        tag: stanza.tag,
+        attributes: Map<String, String>.from(stanza.attributes),
+      ),
+      other: other,
+    );
   }
 
   /// Convenience function that attempts to retrieve the raw XML payload from the
@@ -776,15 +490,12 @@ abstract class OmemoManager extends XmppManagerBase {
   
   /// Retrieves the OMEMO device list from [jid].
   Future<Result<OmemoError, List<int>>> getDeviceList(JID jid) async {
-    if (_deviceMap.containsKey(jid)) return Result(_deviceMap[jid]);
-
     final itemsRaw = await _retrieveDeviceListPayload(jid);
     if (itemsRaw.isType<OmemoError>()) return Result(UnknownOmemoError());
 
     final ids = itemsRaw.get<XMLNode>().children
       .map((child) => int.parse(child.attributes['id']! as String))
       .toList();
-    _deviceMap[jid] = ids;
     return Result(ids);
   }
 
@@ -882,13 +593,9 @@ abstract class OmemoManager extends XmppManagerBase {
   }
 
   /// Subscribes to the device list PubSub node of [jid].
-  Future<void> subscribeToDeviceList(JID jid) async {
+  Future<void> subscribeToDeviceListImpl(String jid) async {
     final pm = getAttributes().getManagerById<PubSubManager>(pubsubManager)!;
-    final result = await pm.subscribe(jid.toString(), omemoDevicesXmlns);
-
-    if (!result.isType<PubSubError>()) {
-      _subscriptionMap[jid] = true;
-    }
+    await pm.subscribe(jid, omemoDevicesXmlns);
   }
 
   /// Attempts to find out if [jid] supports omemo:2.

packages/moxxmpp/lib/src/xeps/xep_0444.dart

@@ -0,0 +1,68 @@
+import 'package:moxxmpp/src/managers/base.dart';
+import 'package:moxxmpp/src/managers/data.dart';
+import 'package:moxxmpp/src/managers/handlers.dart';
+import 'package:moxxmpp/src/managers/namespaces.dart';
+import 'package:moxxmpp/src/namespaces.dart';
+import 'package:moxxmpp/src/stanza.dart';
+import 'package:moxxmpp/src/stringxml.dart';
+
+class MessageReactions {
+  const MessageReactions(this.messageId, this.emojis);
+  final String messageId;
+  final List<String> emojis;
+
+  XMLNode toXml() {
+    return XMLNode.xmlns(
+      tag: 'reactions',
+      xmlns: messageReactionsXmlns,
+      attributes: <String, String>{
+        'id': messageId,
+      },
+      children: emojis.map((emoji) {
+        return XMLNode(
+          tag: 'reaction',
+          text: emoji,
+        );
+      }).toList(),
+    );
+  }
+}
+
+class MessageReactionsManager extends XmppManagerBase {
+  @override
+  List<String> getDiscoFeatures() => [ messageReactionsXmlns ];
+
+  @override
+  String getName() => 'MessageReactionsManager';
+
+  @override
+  String getId() => messageReactionsManager;
+
+  @override
+  List<StanzaHandler> getIncomingStanzaHandlers() => [
+    StanzaHandler(
+      stanzaTag: 'message',
+      tagName: 'reactions',
+      tagXmlns: messageReactionsXmlns,
+      callback: _onReactionsReceived,
+      // Before the message handler
+      priority: -99,
+    ),
+  ];
+
+  @override
+  Future<bool> isSupported() async => true;
+ 
+  Future<StanzaHandlerData> _onReactionsReceived(Stanza message, StanzaHandlerData state) async {
+    final reactionsElement = message.firstTag('reactions', xmlns: messageReactionsXmlns)!;
+    return state.copyWith(
+      messageReactions: MessageReactions(
+        reactionsElement.attributes['id']! as String,
+        reactionsElement.children
+          .where((c) => c.tag == 'reaction')
+          .map((c) => c.innerText())
+          .toList(),
+      ),
+    );
+  }
+}

packages/moxxmpp/lib/src/xeps/xep_0446.dart

@@ -4,7 +4,6 @@ import 'package:moxxmpp/src/xeps/staging/extensible_file_thumbnails.dart';
 import 'package:moxxmpp/src/xeps/xep_0300.dart';
 
 class FileMetadataData {
-
   const FileMetadataData({
     this.mediaType,
     this.width,

packages/moxxmpp/lib/src/xeps/xep_0447.dart

@@ -18,7 +18,6 @@ abstract class StatelessFileSharingSource {
 
 /// Implementation for url-data source elements.
 class StatelessFileSharingUrlSource extends StatelessFileSharingSource {
-
   StatelessFileSharingUrlSource(this.url);
 
   factory StatelessFileSharingUrlSource.fromXml(XMLNode element) {
@@ -41,8 +40,29 @@ class StatelessFileSharingUrlSource extends StatelessFileSharingSource {
   }
 }
 
-class StatelessFileSharingData {
+/// Finds the <sources/> element in [node] and returns the list of
+/// StatelessFileSharingSources contained with it.
+/// If [checkXmlns] is true, then the sources element must also have an xmlns attribute
+/// of "urn:xmpp:sfs:0".
+List<StatelessFileSharingSource> processStatelessFileSharingSources(XMLNode node, { bool checkXmlns = true }) {
+  final sources = List<StatelessFileSharingSource>.empty(growable: true);
+  
+  final sourcesElement = node.firstTag(
+    'sources',
+    xmlns: checkXmlns ? sfsXmlns : null,
+  )!;
+  for (final source in sourcesElement.children) {
+    if (source.attributes['xmlns'] == urlDataXmlns) {
+      sources.add(StatelessFileSharingUrlSource.fromXml(source));
+    } else if (source.attributes['xmlns'] == sfsEncryptionXmlns) {
+      sources.add(StatelessFileSharingEncryptedSource.fromXml(source));
+    }
+  }
 
+  return sources;
+}
+
+class StatelessFileSharingData {
   const StatelessFileSharingData(this.metadata, this.sources);
 
   /// Parse [node] as a StatelessFileSharingData element.
@@ -50,20 +70,10 @@ class StatelessFileSharingData {
     assert(node.attributes['xmlns'] == sfsXmlns, 'Invalid element xmlns');
     assert(node.tag == 'file-sharing', 'Invalid element name');
 
-    final sources = List<StatelessFileSharingSource>.empty(growable: true);
-    
-    final sourcesElement = node.firstTag('sources')!;
-    for (final source in sourcesElement.children) {
-      if (source.attributes['xmlns'] == urlDataXmlns) {
-        sources.add(StatelessFileSharingUrlSource.fromXml(source));
-      } else if (source.attributes['xmlns'] == sfsEncryptionXmlns) {
-        sources.add(StatelessFileSharingEncryptedSource.fromXml(source));
-      }
-    }
-
     return StatelessFileSharingData(
       FileMetadataData.fromXML(node.firstTag('file')!),
-      sources,
+      // TODO(PapaTutuWawa): This is a work around for Stickers where the source element has a XMLNS but SFS does not have one.
+      processStatelessFileSharingSources(node, checkXmlns: false),
     );
   }
 
@@ -120,7 +130,7 @@ class SFSManager extends XmppManagerBase {
     final sfs = message.firstTag('file-sharing', xmlns: sfsXmlns)!;
 
     return state.copyWith(
-      sfs: StatelessFileSharingData.fromXML(sfs),
+      sfs: StatelessFileSharingData.fromXML(sfs, ),
     );
   }
 }

packages/moxxmpp/lib/src/xeps/xep_0449.dart

@@ -0,0 +1,310 @@
+import 'dart:convert';
+import 'package:moxxmpp/src/jid.dart';
+import 'package:moxxmpp/src/managers/base.dart';
+import 'package:moxxmpp/src/managers/data.dart';
+import 'package:moxxmpp/src/managers/handlers.dart';
+import 'package:moxxmpp/src/managers/namespaces.dart';
+import 'package:moxxmpp/src/namespaces.dart';
+import 'package:moxxmpp/src/rfcs/rfc_4790.dart';
+import 'package:moxxmpp/src/stanza.dart';
+import 'package:moxxmpp/src/stringxml.dart';
+import 'package:moxxmpp/src/types/result.dart';
+import 'package:moxxmpp/src/xeps/xep_0060/errors.dart';
+import 'package:moxxmpp/src/xeps/xep_0060/xep_0060.dart';
+import 'package:moxxmpp/src/xeps/xep_0300.dart';
+import 'package:moxxmpp/src/xeps/xep_0446.dart';
+import 'package:moxxmpp/src/xeps/xep_0447.dart';
+
+class Sticker {
+  const Sticker(this.metadata, this.sources, this.suggests);
+
+  factory Sticker.fromXML(XMLNode node) {
+    assert(node.tag == 'item', 'sticker has wrong tag');
+
+    return Sticker(
+      FileMetadataData.fromXML(node.firstTag('file', xmlns: fileMetadataXmlns)!),
+      processStatelessFileSharingSources(node, checkXmlns: false),
+      {},
+    );
+  }
+
+  final FileMetadataData metadata;
+  final List<StatelessFileSharingSource> sources;
+  // Language -> suggestion
+  final Map<String, String> suggests; 
+
+  XMLNode toPubSubXML() {
+    final suggestsElements = suggests.keys.map((suggest) {
+      Map<String, String> attrs;
+      if (suggest.isEmpty) {
+        attrs = {};
+      } else {
+        attrs = {
+          'xml:lang': suggest,
+        };
+      }
+
+      return XMLNode(
+        tag: 'suggest',
+        attributes: attrs,
+        text: suggests[suggest],
+      );
+    });
+
+    return XMLNode(
+      tag: 'item',
+      children: [
+        metadata.toXML(),
+        ...sources.map((source) => source.toXml()),
+        ...suggestsElements,
+      ],
+    );
+  }
+}
+
+class StickerPack {
+  const StickerPack(
+    this.id,
+    this.name,
+    this.summary,
+    this.hashAlgorithm,
+    this.hashValue,
+    this.stickers,
+    this.restricted,
+  );
+
+  factory StickerPack.fromXML(String id, XMLNode node, { bool hashAvailable = true }) {
+    assert(node.tag == 'pack', 'node has wrong tag');
+    assert(node.attributes['xmlns'] == stickersXmlns, 'node has wrong XMLNS');
+
+    var hashAlgorithm = HashFunction.sha256;
+    var hashValue = '';
+    if (hashAvailable) {
+      final hash = node.firstTag('hash', xmlns: hashXmlns)!;
+      hashAlgorithm = hashFunctionFromName(hash.attributes['algo']! as String);
+      hashValue = hash.innerText();
+    }
+    
+    return StickerPack(
+      id,
+      node.firstTag('name')!.innerText(),
+      node.firstTag('summary')!.innerText(),
+      hashAlgorithm,
+      hashValue,
+      node.children
+        .where((e) => e.tag == 'item')
+        .map<Sticker>(Sticker.fromXML)
+        .toList(),
+      node.firstTag('restricted') != null,
+    );
+  }
+
+  final String id;
+  // TODO(PapaTutuWawa): Turn name and summary into a Map as it may contain a xml:lang
+  final String name;
+  final String summary;
+  final HashFunction hashAlgorithm;
+  final String hashValue;
+  final List<Sticker> stickers;
+  final bool restricted;
+
+  /// When using the fromXML factory to parse a description of a sticker pack with a
+  /// yet unknown hash, then this function can be used in order to apply the freshly
+  /// calculated hash to the object.
+  StickerPack copyWithId(HashFunction newHashFunction, String newId) {
+    return StickerPack(
+      newId,
+      name,
+      summary,
+      newHashFunction,
+      newId,
+      stickers,
+      restricted,
+    );
+  }
+  
+  XMLNode toXML() {
+    return XMLNode.xmlns(
+      tag: 'pack',
+      xmlns: stickersXmlns,
+      children: [
+        // Pack metadata
+        XMLNode(
+          tag: 'name',
+          text: name,
+        ),
+        XMLNode(
+          tag: 'summary',
+          text: summary,
+        ),
+        constructHashElement(
+          hashAlgorithm.toName(),
+          hashValue,
+        ),
+
+        ...restricted ?
+          [XMLNode(tag: 'restricted')] :
+          [],
+        
+        // Stickers
+        ...stickers
+          .map((sticker) => sticker.toPubSubXML()),
+      ],
+    );
+  }
+
+  /// Calculates the sticker pack's hash as specified by XEP-0449.
+  Future<String> getHash(HashFunction hashFunction) async {
+    // Build the meta string
+    final metaTmp = [
+      <int>[
+        ...utf8.encode('name'),
+        0x1f,
+        0x1f,
+        ...utf8.encode(name),
+        0x1f,
+        0x1e,
+      ],
+      <int>[
+        ...utf8.encode('summary'),
+        0x1f,
+        0x1f,
+        ...utf8.encode(summary),
+        0x1f,
+        0x1e,
+      ],
+    ]..sort(ioctetSortComparatorRaw);
+    final metaString = List<int>.empty(growable: true);
+    for (final m in metaTmp) {
+      metaString.addAll(m);
+    }
+    metaString.add(0x1c);
+
+    // Build item hashes
+    final items = List<List<int>>.empty(growable: true);
+    for (final sticker in stickers) {
+      final tmp = List<int>.empty(growable: true)
+        ..addAll(utf8.encode(sticker.metadata.desc!))
+        ..add(0x1e);
+
+      final hashes = List<List<int>>.empty(growable: true);
+      for (final hash in sticker.metadata.hashes.keys) {
+        hashes.add([
+          ...utf8.encode(hash),
+          0x1f,
+          ...utf8.encode(sticker.metadata.hashes[hash]!),
+          0x1f,
+          0x1e,
+        ]);
+      }
+      hashes.sort(ioctetSortComparatorRaw);
+
+      for (final hash in hashes) {
+        tmp.addAll(hash);
+      }
+      tmp.add(0x1d);
+      items.add(tmp);
+    }
+    items.sort(ioctetSortComparatorRaw);
+    final stickersString = List<int>.empty(growable: true);
+    for (final item in items) {
+      stickersString.addAll(item);
+    }
+    stickersString.add(0x1c);
+
+    // Calculate the hash
+    final rawHash = await CryptographicHashManager.hashFromData(
+      [
+        ...metaString,
+        ...stickersString,
+      ],
+      hashFunction,
+    );
+    return base64.encode(rawHash).substring(0, 24);
+  }
+}
+
+class StickersManager extends XmppManagerBase {
+  @override
+  String getId() => stickersManager;
+
+  @override
+  String getName() => 'StickersManager';
+
+  @override
+  Future<bool> isSupported() async => true;
+
+  @override
+  List<StanzaHandler> getIncomingStanzaHandlers() => [
+    StanzaHandler(
+      stanzaTag: 'message',
+      tagXmlns: stickersXmlns,
+      tagName: 'sticker',
+      callback: _onIncomingMessage,
+      priority: -99,
+    ),
+  ];
+
+  Future<StanzaHandlerData> _onIncomingMessage(Stanza stanza, StanzaHandlerData state) async {
+    final sticker = stanza.firstTag('sticker', xmlns: stickersXmlns)!;
+    return state.copyWith(
+      stickerPackId: sticker.attributes['pack']! as String,
+    );
+  }
+
+  /// Publishes the StickerPack [pack] to the PubSub node of [jid]. If specified, then
+  /// [accessModel] will be used as the PubSub node's access model.
+  ///
+  /// On success, returns true. On failure, returns a PubSubError.
+  Future<Result<PubSubError, bool>> publishStickerPack(JID jid, StickerPack pack, { String? accessModel }) async {
+    assert(pack.id != '', 'The sticker pack must have an id');
+    final pm = getAttributes().getManagerById<PubSubManager>(pubsubManager)!;
+
+    return pm.publish(
+      jid.toBare().toString(),
+      stickersXmlns,
+      pack.toXML(),
+      id: pack.id,
+      options: PubSubPublishOptions(
+        maxItems: 'max',
+        accessModel: accessModel,
+      ),
+    );
+  }
+
+  /// Removes the sticker pack with id [id] from the PubSub node of [jid].
+  ///
+  /// On success, returns the true. On failure, returns a PubSubError.
+  Future<Result<PubSubError, bool>> retractStickerPack(JID jid, String id) async {
+    final pm = getAttributes().getManagerById<PubSubManager>(pubsubManager)!;
+
+    return pm.retract(
+      jid,
+      stickersXmlns,
+      id,
+    );
+  }
+
+  /// Fetches the sticker pack with id [id] from [jid].
+  ///
+  /// On success, returns the StickerPack. On failure, returns a PubSubError.
+  Future<Result<PubSubError, StickerPack>> fetchStickerPack(JID jid, String id) async {
+    final pm = getAttributes().getManagerById<PubSubManager>(pubsubManager)!;
+    final stickerPackDataRaw = await pm.getItem(
+      jid.toBare().toString(),
+      stickersXmlns,
+      id,
+    );
+    if (stickerPackDataRaw.isType<PubSubError>()) {
+      return Result(stickerPackDataRaw.get<PubSubError>());
+    }
+
+    final stickerPackData = stickerPackDataRaw.get<PubSubItem>();
+    final stickerPack = StickerPack.fromXML(
+      stickerPackData.id,
+      stickerPackData.payload,
+    );
+
+    return Result(stickerPack);
+  }
+}

packages/moxxmpp/lib/src/xeps/xep_0461.dart

@@ -1,3 +1,4 @@
+import 'package:meta/meta.dart';
 import 'package:moxxmpp/src/managers/base.dart';
 import 'package:moxxmpp/src/managers/data.dart';
 import 'package:moxxmpp/src/managers/handlers.dart';
@@ -5,20 +6,65 @@ import 'package:moxxmpp/src/managers/namespaces.dart';
 import 'package:moxxmpp/src/namespaces.dart';
 import 'package:moxxmpp/src/stanza.dart';
 
+/// Data summarizing the XEP-0461 data.
 class ReplyData {
-
   const ReplyData({
-      required this.to,
-      required this.id,
-      this.start,
-      this.end,
+    required this.to,
+    required this.id,
+    this.start,
+    this.end,
   });
+
+  /// The bare JID to whom the reply applies to
   final String to;
+
+  /// The stanza ID of the message that is replied to
   final String id;
+
+  /// The start of the fallback body (inclusive)
   final int? start;
+
+  /// The end of the fallback body (exclusive)
   final int? end;
+
+  /// Applies the metadata to the received body [body] in order to remove the fallback.
+  /// If either [ReplyData.start] or [ReplyData.end] are null, then body is returned as
+  /// is.
+  String removeFallback(String body) {
+    if (start == null || end == null) return body;
+
+    return body.replaceRange(start!, end, '');
+  }
 }
 
+/// Internal class describing how to build a message with a quote fallback body.
+@visibleForTesting
+class QuoteData {
+  const QuoteData(this.body, this.fallbackLength);
+
+  /// Takes the body of the message we want to quote [quoteBody] and the content of
+  /// the reply [body] and computes the fallback body and its length.
+  factory QuoteData.fromBodies(String quoteBody, String body) {
+    final fallback = quoteBody
+      .split('\n')
+      .map((line) => '> $line\n')
+      .join();
+
+    return QuoteData(
+      '$fallback$body',
+      fallback.length,
+    );
+  }
+  
+  /// The new body with fallback data at the beginning
+  final String body;
+
+  /// The length of the fallback data
+  final int fallbackLength;
+}
+
+/// A manager implementing support for parsing XEP-0461 metadata. The
+/// MessageRepliesManager itself does not modify the body of the message.
 class MessageRepliesManager extends XmppManagerBase {
   @override
   String getName() => 'MessageRepliesManager';

packages/moxxmpp/pubspec.yaml

@@ -8,6 +8,7 @@ environment:
   sdk: '>=2.17.5 <3.0.0'
 
 dependencies:
+  collection: ^1.16.0
   cryptography: ^2.0.5
   freezed: ^2.1.0+1
   freezed_annotation: ^2.1.0
@@ -19,8 +20,8 @@ dependencies:
    hosted: https://git.polynom.me/api/packages/Moxxy/pub
    version: ^0.1.5
   omemo_dart:
-   hosted: https://git.polynom.me/api/packages/PapaTutuWawa/pub
-   version: ^0.3.2
+    hosted: https://git.polynom.me/api/packages/PapaTutuWawa/pub
+    version: ^0.4.2
   random_string: ^2.3.1
   saslprep: ^1.0.2
   synchronized: ^3.0.0+2

packages/moxxmpp/test/jid_test.dart

@@ -1,41 +1,55 @@
 import 'package:moxxmpp/moxxmpp.dart';
 import 'package:test/test.dart';
-
 void main() {
   test('Parse a full JID', () {
-      final jid = JID.fromString('test@server/abc');
+    final jid = JID.fromString('test@server/abc');
 
-      expect(jid.local, 'test');
-      expect(jid.domain, 'server');
-      expect(jid.resource, 'abc');
-      expect(jid.toString(), 'test@server/abc');
+    expect(jid.local, 'test');
+    expect(jid.domain, 'server');
+    expect(jid.resource, 'abc');
+    expect(jid.toString(), 'test@server/abc');
   });
 
   test('Parse a bare JID', () {
-      final jid = JID.fromString('test@server');
+    final jid = JID.fromString('test@server');
 
-      expect(jid.local, 'test');
-      expect(jid.domain, 'server');
-      expect(jid.resource, '');
-      expect(jid.toString(), 'test@server');
+    expect(jid.local, 'test');
+    expect(jid.domain, 'server');
+    expect(jid.resource, '');
+    expect(jid.toString(), 'test@server');
   });
 
   test('Parse a JID with no local part', () {
-      final jid = JID.fromString('server/abc');
+    final jid = JID.fromString('server/abc');
 
-      expect(jid.local, '');
-      expect(jid.domain, 'server');
-      expect(jid.resource, 'abc');
-      expect(jid.toString(), 'server/abc');
+    expect(jid.local, '');
+    expect(jid.domain, 'server');
+    expect(jid.resource, 'abc');
+    expect(jid.toString(), 'server/abc');
   });
 
   test('Equality', () {
-      expect(JID.fromString('hallo@welt/abc') == JID('hallo', 'welt', 'abc'), true);
-      expect(JID.fromString('hallo@welt') == JID('hallo', 'welt', 'a'), false);
+    expect(JID.fromString('hallo@welt/abc') == JID('hallo', 'welt', 'abc'), true);
+    expect(JID.fromString('hallo@welt') == JID('hallo', 'welt', 'a'), false);
   });
 
-  test('Whitespaces', () {
-      expect(JID.fromString('hallo@welt ') == JID('hallo', 'welt', ''), true);
-      expect(JID.fromString('hallo@welt/abc ') == JID('hallo', 'welt', 'abc'), true);
+  test('Dot suffix at domain part', () {
+    expect(JID.fromString('hallo@welt.example.') == JID('hallo', 'welt.example', ''), true);
+    expect(JID.fromString('hallo@welt.example./test') == JID('hallo', 'welt.example', 'test'), true);
+  });
+
+  test('Parse resource with a slash', () {
+    expect(JID.fromString('hallo@welt.example./test/welt') == JID('hallo', 'welt.example', 'test/welt'), true);
+  });
+
+  test('bareCompare', () {
+    final jid1 = JID('hallo', 'welt', 'lol');
+    final jid2 = JID('hallo', 'welt', '');
+    final jid3 = JID('hallo', 'earth', 'true');
+
+    expect(jid1.bareCompare(jid2), true);
+    expect(jid2.bareCompare(jid1), true);
+    expect(jid2.bareCompare(jid1, ensureBare: true), false);
+    expect(jid2.bareCompare(jid3), false);
   });
 }

packages/moxxmpp/test/negotiator_test.dart

@@ -61,7 +61,7 @@ void main() {
     ])
     ..registerManagers([
       PresenceManager('http://moxxmpp.example'),
-      RosterManager(),
+      RosterManager(TestingRosterStateManager('', [])),
       DiscoManager(),
       PingManager(),
     ])

packages/moxxmpp/test/roster_state_test.dart

@@ -0,0 +1,153 @@
+import 'package:moxxmpp/moxxmpp.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('Test receiving a roster push', () async {
+    final rs = TestingRosterStateManager(null, []);
+    rs.register((_) {});
+
+    await rs.handleRosterPush(
+      RosterPushResult(
+        XmppRosterItem(
+          jid: 'testuser@server.example',
+          subscription: 'both',
+        ),
+        null,
+      ),
+    );
+
+    expect(
+      rs.getRosterItems().indexWhere((item) => item.jid == 'testuser@server.example') != -1,
+      true,
+    );
+    expect(rs.loadCount, 1);
+    expect(rs.getRosterItems().length, 1);
+
+    // Receive another roster push
+    await rs.handleRosterPush(
+      RosterPushResult(
+        XmppRosterItem(
+          jid: 'testuser2@server2.example',
+          subscription: 'to',
+        ),
+        null,
+      ),
+    );
+
+    expect(
+      rs.getRosterItems().indexWhere((item) => item.jid == 'testuser2@server2.example') != -1,
+      true,
+    );
+    expect(rs.loadCount, 1);
+    expect(rs.getRosterItems().length, 2);
+
+    // Remove one of the items
+     await rs.handleRosterPush(
+      RosterPushResult(
+        XmppRosterItem(
+          jid: 'testuser2@server2.example',
+          subscription: 'remove',
+        ),
+        null,
+      ),
+    );
+
+    expect(
+      rs.getRosterItems().indexWhere((item) => item.jid == 'testuser2@server2.example') == -1,
+      true,
+    );
+    expect(
+      rs.getRosterItems().indexWhere((item) => item.jid == 'testuser@server.example') != 1,
+      true,
+    );
+    expect(rs.loadCount, 1);
+    expect(rs.getRosterItems().length, 1);   
+  });
+
+  test('Test a roster fetch', () async {
+    final rs = TestingRosterStateManager(null, []);
+    rs.register((_) {});
+
+    // Fetch the roster
+    await rs.handleRosterFetch(
+      RosterRequestResult(
+        [
+          XmppRosterItem(
+            jid: 'testuser@server.example',
+            subscription: 'both',
+          ),
+          XmppRosterItem(
+            jid: 'testuser2@server2.example',
+            subscription: 'to',
+          ),
+          XmppRosterItem(
+            jid: 'testuser3@server3.example',
+            subscription: 'from',
+          ),
+        ],
+        'aaaaaaaa',
+      ),
+    );
+
+    expect(rs.loadCount, 1);
+    expect(rs.getRosterItems().length, 3);
+    expect(rs.getRosterItems().indexWhere((item) => item.jid == 'testuser@server.example') != -1, true);
+    expect(rs.getRosterItems().indexWhere((item) => item.jid == 'testuser2@server2.example') != -1, true);
+    expect(rs.getRosterItems().indexWhere((item) => item.jid == 'testuser3@server3.example') != -1, true);
+  });
+
+  test('Test a roster fetch if we already have a roster', () async {
+    XmppEvent? event;
+    final rs = TestingRosterStateManager('aaaaa', [
+      XmppRosterItem(
+        jid: 'testuser@server.example',
+        subscription: 'both',
+      ),
+      XmppRosterItem(
+        jid: 'testuser2@server2.example',
+        subscription: 'to',
+      ),
+      XmppRosterItem(
+        jid: 'testuser3@server3.example',
+        subscription: 'from',
+      ),
+    ]);
+    rs.register((_event) {
+      event = _event;
+    });
+
+    // Fetch the roster
+    await rs.handleRosterFetch(
+      RosterRequestResult(
+        [
+          XmppRosterItem(
+            jid: 'testuser@server.example',
+            subscription: 'both',
+          ),
+          XmppRosterItem(
+            jid: 'testuser2@server2.example',
+            subscription: 'to',
+          ),
+          XmppRosterItem(
+            jid: 'testuser3@server3.example',
+            subscription: 'both',
+          ),
+          XmppRosterItem(
+            jid: 'testuser4@server4.example',
+            subscription: 'both',
+          ),
+        ],
+        'bbbbb',
+      ),
+    );
+
+    expect(event is RosterUpdatedEvent, true);
+    final updateEvent = event as RosterUpdatedEvent;
+
+    expect(updateEvent.added.length, 1);
+    expect(updateEvent.added.first.jid, 'testuser4@server4.example');
+    expect(updateEvent.modified.length, 1);
+    expect(updateEvent.modified.first.jid, 'testuser3@server3.example');
+    expect(updateEvent.removed.isEmpty, true);
+  });
+}

packages/moxxmpp/test/roster_test.dart

@@ -1,322 +0,0 @@
-import 'package:moxxmpp/moxxmpp.dart';
-import 'package:test/test.dart';
-
-// TODO(PapaTutuWawa): Fix tests
-
-typedef AddRosterItemFunction = Future<RosterItem> Function(
-  String avatarUrl,
-  String avatarHash,
-  String jid,
-  String title,
-  String subscription,
-  String ask,
-  {
-    List<String> groups,
-  }
-);
-
-typedef UpdateRosterItemFunction = Future<RosterItem> Function(
-  int id, {
-    String? avatarUrl,
-    String? avatarHash,
-    String? title,
-    String? subscription,
-    String? ask,
-    List<String>? groups,
-  }
-);
-
-AddRosterItemFunction mkAddRosterItem(void Function(String) callback) {
-  return (
-    String avatarUrl,
-    String avatarHash,
-    String jid,
-    String title,
-    String subscription,
-    String ask,
-    {
-      List<String> groups = const [],
-    }
-  ) async {
-    callback(jid);
-    return await addRosterItemFromData(
-      avatarUrl,
-      avatarHash,
-      jid,
-      title,
-      subscription,
-      ask,
-      groups: groups,
-    );
-  };
-}
-
-Future<RosterItem> addRosterItemFromData(
-  String avatarUrl,
-  String avatarHash,
-  String jid,
-  String title,
-  String subscription,
-  String ask,
-  {
-    List<String> groups = const [],
-  }
-) async => RosterItem(
-  0,
-  avatarUrl,
-  avatarHash,
-  jid,
-  title,
-  subscription,
-  ask,
-  groups,
-);
-
-UpdateRosterItemFunction mkRosterUpdate(List<RosterItem> roster) {
-  return (
-    int id, {
-      String? avatarUrl,
-      String? avatarHash,
-      String? title,
-      String? subscription,
-      String? ask,
-      List<String>? groups,
-    }
-  ) async {
-    final item = firstWhereOrNull(roster, (RosterItem item) => item.id == id)!;
-    return item.copyWith(
-      avatarUrl: avatarUrl ?? item.avatarUrl,
-      avatarHash: avatarHash ?? item.avatarHash,
-      title: title ?? item.title,
-      subscription: subscription ?? item.subscription,
-      ask: ask ?? item.ask,
-      groups: groups ?? item.groups,
-    );
-  };
-}
-
-void main() {
-  final localRosterSingle = [
-    RosterItem(
-      0,
-      '',
-      '',
-      'hallo@server.example',
-      'hallo',
-      'none',
-      '',
-      [],
-    )
-  ];
-  final localRosterDouble = [
-    RosterItem(
-      0,
-      '',
-      '',
-      'hallo@server.example',
-      'hallo',
-      'none',
-      '',
-      [],
-    ),
-    RosterItem(
-      1,
-      '',
-      '',
-      'welt@different.server.example',
-      'welt',
-      'from',
-      '',
-      [ 'Friends' ],
-    )
-  ];
-
-  group('Test roster pushes', () {
-      test('Test removing an item', () async {
-          var removeCalled = false;
-          var addCalled = false;
-          final result = await processRosterDiff(
-            localRosterDouble,
-            [
-              XmppRosterItem(
-                jid: 'hallo@server.example', subscription: 'remove',
-              ) 
-            ],
-            true,
-            mkAddRosterItem((_) { addCalled = true; }),
-            mkRosterUpdate(localRosterDouble),
-            (jid) async {
-              if (jid == 'hallo@server.example') {
-                removeCalled = true;
-              }
-            },
-            (_) async => null,
-            (_, { String? id }) async {},
-          );
-
-          expect(result.removed, [ 'hallo@server.example' ]);
-          expect(result.modified.length, 0);
-          expect(result.added.length, 0);
-          expect(removeCalled, true);
-          expect(addCalled, false);
-      });
-
-      test('Test adding an item', () async {
-          var removeCalled = false;
-          var addCalled = false;
-          final result = await processRosterDiff(
-            localRosterSingle,
-            [
-              XmppRosterItem(
-                jid: 'welt@different.server.example',
-                subscription: 'from',
-              ) 
-            ],
-            true,
-            mkAddRosterItem(
-              (jid) {
-                if (jid == 'welt@different.server.example') {
-                  addCalled = true;
-                }
-              }
-            ),
-            mkRosterUpdate(localRosterSingle),
-            (_) async { removeCalled = true; },
-            (_) async => null,
-            (_, { String? id }) async {},
-          );
-
-          expect(result.removed, [ ]);
-          expect(result.modified.length, 0);
-          expect(result.added.length, 1);
-          expect(result.added.first.subscription, 'from');
-          expect(removeCalled, false);
-          expect(addCalled, true);
-      });
-
-      test('Test modifying an item', () async {
-          var removeCalled = false;
-          var addCalled = false;
-          final result = await processRosterDiff(
-            localRosterDouble,
-            [
-              XmppRosterItem(
-                jid: 'welt@different.server.example',
-                subscription: 'both',
-                name: 'The World',
-              ) 
-            ],
-            true,
-            mkAddRosterItem((_) { addCalled = false; }),
-            mkRosterUpdate(localRosterDouble),
-            (_) async { removeCalled = true; },
-            (_) async => null,
-            (_, { String? id }) async {},
-          );
-
-          expect(result.removed, [ ]);
-          expect(result.modified.length, 1);
-          expect(result.added.length, 0);
-          expect(result.modified.first.subscription, 'both');
-          expect(result.modified.first.jid, 'welt@different.server.example');
-          expect(result.modified.first.title, 'The World');
-          expect(removeCalled, false);
-          expect(addCalled, false);
-      });
-  });
-
-  group('Test roster requests', () {
-      test('Test removing an item', () async {
-          var removeCalled = false;
-          var addCalled = false;
-          final result = await processRosterDiff(
-            localRosterSingle,
-            [],
-            false,
-            mkAddRosterItem((_) { addCalled = true; }),
-            mkRosterUpdate(localRosterDouble),
-            (jid) async {
-              if (jid == 'hallo@server.example') {
-                removeCalled = true;
-              }
-            },
-            (_) async => null,
-            (_, { String? id }) async {},
-          );
-
-          expect(result.removed, [ 'hallo@server.example' ]);
-          expect(result.modified.length, 0);
-          expect(result.added.length, 0);
-          expect(removeCalled, true);
-          expect(addCalled, false);
-      });
-
-      test('Test adding an item', () async {
-          var removeCalled = false;
-          var addCalled = false;
-          final result = await processRosterDiff(
-            localRosterSingle,
-            [
-              XmppRosterItem(
-                jid: 'hallo@server.example',
-                name: 'hallo',
-                subscription: 'none',
-              ),
-              XmppRosterItem(
-                jid: 'welt@different.server.example',
-                subscription: 'both',
-              )
-            ],
-            false,
-            mkAddRosterItem(
-              (jid) {
-                if (jid == 'welt@different.server.example') {
-                  addCalled = true;
-                }
-              }
-            ),
-            mkRosterUpdate(localRosterSingle),
-            (_) async { removeCalled = true; },
-            (_) async => null,
-            (_, { String? id }) async {},
-          );
-
-          expect(result.removed, [ ]);
-          expect(result.modified.length, 0);
-          expect(result.added.length, 1);
-          expect(result.added.first.subscription, 'both');
-          expect(removeCalled, false);
-          expect(addCalled, true);
-      });
-
-      test('Test modifying an item', () async {
-          var removeCalled = false;
-          var addCalled = false;
-          final result = await processRosterDiff(
-            localRosterSingle,
-            [
-              XmppRosterItem(
-                jid: 'hallo@server.example',
-                subscription: 'both',
-                name: 'Hallo Welt',
-              ) 
-            ],
-            false,
-            mkAddRosterItem((_) { addCalled = false; }),
-            mkRosterUpdate(localRosterDouble),
-            (_) async { removeCalled = true; },
-            (_) async => null,
-            (_, { String? id }) async {},
-          );
-
-          expect(result.removed, [ ]);
-          expect(result.modified.length, 1);
-          expect(result.added.length, 0);
-          expect(result.modified.first.subscription, 'both');
-          expect(result.modified.first.jid, 'hallo@server.example');
-          expect(result.modified.first.title, 'Hallo Welt');
-          expect(removeCalled, false);
-          expect(addCalled, false);
-      });
-  });
-}

packages/moxxmpp/test/xeps/xep_0198_test.dart

@@ -4,7 +4,7 @@ import '../helpers/logging.dart';
 import '../helpers/xmpp.dart';
 
 Future<void> runIncomingStanzaHandlers(StreamManagementManager man, Stanza stanza) async {
-  for (final handler in man.getIncomingStanzaHandlers()) {
+  for (final handler in man.getIncomingPreStanzaHandlers()) {
     if (handler.matches(stanza)) await handler.callback(stanza, StanzaHandlerData(false, false, null, stanza));
   }
 }
@@ -243,7 +243,7 @@ void main() {
       final sm = StreamManagementManager();
       conn.registerManagers([
           PresenceManager('http://moxxmpp.example'),
-          RosterManager(),
+          RosterManager(TestingRosterStateManager('', [])),
           DiscoManager(),
           PingManager(),
           sm,
@@ -348,7 +348,7 @@ void main() {
           ),
           StanzaExpectation(
             "<iq to='user@example.com' type='get' id='a' xmlns='jabber:client' />",
-            "<iq to='user@example.com' type='result' id='a' />",
+            "<iq from='user@example.com' type='result' id='a' />",
             ignoreId: true,
             adjustId: true,
           ),
@@ -365,7 +365,7 @@ void main() {
       final sm = StreamManagementManager();
       conn.registerManagers([
           PresenceManager('http://moxxmpp.example'),
-          RosterManager(),
+          RosterManager(TestingRosterStateManager('', [])),
           DiscoManager(),
           PingManager(),
           sm,
@@ -519,7 +519,7 @@ void main() {
       ),);
       conn.registerManagers([
           PresenceManager('http://moxxmpp.example'),
-          RosterManager(),
+          RosterManager(TestingRosterStateManager('', [])),
           DiscoManager(),
           PingManager(),
           StreamManagementManager(),
@@ -611,7 +611,7 @@ void main() {
       ),);
       conn.registerManagers([
           PresenceManager('http://moxxmpp.example'),
-          RosterManager(),
+          RosterManager(TestingRosterStateManager('', [])),
           DiscoManager(),
           PingManager(),
           StreamManagementManager(),
@@ -703,7 +703,7 @@ void main() {
       ),);
       conn.registerManagers([
           PresenceManager('http://moxxmpp.example'),
-          RosterManager(),
+          RosterManager(TestingRosterStateManager('', [])),
           DiscoManager(),
           PingManager(),
           StreamManagementManager(),

packages/moxxmpp/test/xeps/xep_0280_test.dart

@@ -4,33 +4,33 @@ import '../helpers/xmpp.dart';
 
 void main() {
   test("Test if we're vulnerable against CVE-2020-26547 style vulnerabilities", () async {
-      final attributes = XmppManagerAttributes(
-        sendStanza: (stanza, { StanzaFromType addFrom = StanzaFromType.full, bool addId = true, bool retransmitted = false, bool awaitable = true, bool encrypted = false }) async {
-          // ignore: avoid_print
-          print('==> ${stanza.toXml()}');
-          return XMLNode(tag: 'iq', attributes: { 'type': 'result' });
-        },
-        sendNonza: (nonza) {},
-        sendEvent: (event) {},
-        getManagerById: getManagerNullStub,
-        getConnectionSettings: () => ConnectionSettings(
-          jid: JID.fromString('bob@xmpp.example'),
-          password: 'password',
-          useDirectTLS: true,
-          allowPlainAuth: false,
-        ),
-        isFeatureSupported: (_) => false,
-        getFullJID: () => JID.fromString('bob@xmpp.example/uwu'),
-        getSocket: () => StubTCPSocket(play: []),
-        getConnection: () => XmppConnection(TestingReconnectionPolicy(), StubTCPSocket(play: [])),
-        getNegotiatorById: getNegotiatorNullStub,
-      );
-      final manager = CarbonsManager();
-      manager.register(attributes);
-      await manager.enableCarbons();
+    final attributes = XmppManagerAttributes(
+      sendStanza: (stanza, { StanzaFromType addFrom = StanzaFromType.full, bool addId = true, bool retransmitted = false, bool awaitable = true, bool encrypted = false }) async {
+        // ignore: avoid_print
+        print('==> ${stanza.toXml()}');
+        return XMLNode(tag: 'iq', attributes: { 'type': 'result' });
+      },
+      sendNonza: (nonza) {},
+      sendEvent: (event) {},
+      getManagerById: getManagerNullStub,
+      getConnectionSettings: () => ConnectionSettings(
+        jid: JID.fromString('bob@xmpp.example'),
+        password: 'password',
+        useDirectTLS: true,
+        allowPlainAuth: false,
+      ),
+      isFeatureSupported: (_) => false,
+      getFullJID: () => JID.fromString('bob@xmpp.example/uwu'),
+      getSocket: () => StubTCPSocket(play: []),
+      getConnection: () => XmppConnection(TestingReconnectionPolicy(), StubTCPSocket(play: [])),
+      getNegotiatorById: getNegotiatorNullStub,
+    );
+    final manager = CarbonsManager();
+    manager.register(attributes);
+    await manager.enableCarbons();
 
-      expect(manager.isCarbonValid(JID.fromString('mallory@evil.example')), false);
-      expect(manager.isCarbonValid(JID.fromString('bob@xmpp.example')), true);
-      expect(manager.isCarbonValid(JID.fromString('bob@xmpp.example/abc')), false);
+    expect(manager.isCarbonValid(JID.fromString('mallory@evil.example')), false);
+    expect(manager.isCarbonValid(JID.fromString('bob@xmpp.example')), true);
+    expect(manager.isCarbonValid(JID.fromString('bob@xmpp.example/abc')), false);
   });
 }

packages/moxxmpp/test/xeps/xep_0461_test.dart

@@ -0,0 +1,44 @@
+import 'package:moxxmpp/moxxmpp.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('Test building a singleline quote', () {
+    final quote = QuoteData.fromBodies('Hallo Welt', 'Hello Earth!');
+
+    expect(quote.body, '> Hallo Welt\nHello Earth!');
+    expect(quote.fallbackLength, 13);
+  });
+
+  test('Test building a multiline quote', () {
+    final quote = QuoteData.fromBodies('Hallo Welt\nHallo Erde', 'How are you?');
+
+    expect(quote.body, '> Hallo Welt\n> Hallo Erde\nHow are you?');
+    expect(quote.fallbackLength, 26);
+  });
+
+  test('Applying a singleline quote', () {
+    final body = '> Hallo Welt\nHello right back!';
+    final reply = ReplyData(
+      to: '',
+      id: '',
+      start: 0,
+      end: 13,
+    );
+
+    final bodyWithoutFallback = reply.removeFallback(body);
+    expect(bodyWithoutFallback, 'Hello right back!');
+  });
+
+  test('Applying a multiline quote', () {
+    final body = "> Hallo Welt\n> How are you?\nI'm fine.\nThank you!";
+    final reply = ReplyData(
+      to: '',
+      id: '',
+      start: 0,
+      end: 28,
+    );
+
+    final bodyWithoutFallback = reply.removeFallback(body);
+    expect(bodyWithoutFallback, "I'm fine.\nThank you!");
+  });
+}

packages/moxxmpp/test/xmpp_test.dart

@@ -7,7 +7,7 @@ import 'helpers/xmpp.dart';
 /// Returns true if the roster manager triggeres an event for a given stanza
 Future<bool> testRosterManager(String bareJid, String resource, String stanzaString) async {
   var eventTriggered = false;
-  final roster = RosterManager();
+  final roster = RosterManager(TestingRosterStateManager('', []));
   roster.register(XmppManagerAttributes(
       sendStanza: (_, { StanzaFromType addFrom = StanzaFromType.full, bool addId = true, bool retransmitted = false, bool awaitable = true, bool encrypted = false }) async => XMLNode(tag: 'hallo'),
       sendEvent: (event) {
@@ -127,7 +127,7 @@ void main() {
       ),);
       conn.registerManagers([
         PresenceManager('http://moxxmpp.example'),
-        RosterManager(),
+        RosterManager(TestingRosterStateManager('', [])),
         DiscoManager(),
         PingManager(),
         StreamManagementManager(),
@@ -181,7 +181,7 @@ void main() {
       ),);
       conn.registerManagers([
         PresenceManager('http://moxxmpp.example'),
-        RosterManager(),
+        RosterManager(TestingRosterStateManager('', [])),
         DiscoManager(),
         PingManager(),
       ]);
@@ -235,7 +235,7 @@ void main() {
       ),);
       conn.registerManagers([
         PresenceManager('http://moxxmpp.example'),
-        RosterManager(),
+        RosterManager(TestingRosterStateManager('', [])),
         DiscoManager(),
         PingManager(),
       ]);
@@ -290,7 +290,7 @@ void main() {
       ),);
       conn.registerManagers([
         PresenceManager('http://moxxmpp.example'),
-        RosterManager(),
+        RosterManager(TestingRosterStateManager('', [])),
         DiscoManager(),
         PingManager(),
       ]);
@@ -308,7 +308,7 @@ void main() {
   group('Test roster pushes', () {
       test('Test for a CVE-2015-8688 style vulnerability', () async {
           var eventTriggered = false;
-          final roster = RosterManager();
+          final roster = RosterManager(TestingRosterStateManager('', []));
           roster.register(XmppManagerAttributes(
               sendStanza: (_, { StanzaFromType addFrom = StanzaFromType.full, bool addId = true, bool retransmitted = false, bool awaitable = true, bool encrypted = false }) async => XMLNode(tag: 'hallo'),
               sendEvent: (event) {

packages/moxxmpp_socket_tcp/README.md

@@ -11,6 +11,22 @@ to return the list of SRV records, encoded by `MoxSrvRecord` objects. To perform
 resolution, one can use any DNS library. A Flutter plugin implementing SRV resolution
 is, for example, [moxdns](https://codeberg.org/moxxy/moxdns).
 
+## Usage
+
+Include the following as a dependency in your pubspec file:
+
+```
+ moxxmpp_socket_tcp:
+    hosted: https://git.polynom.me/api/packages/Moxxy/pub
+    version: 0.1.2+9
+```
+
 ## License
 
 See `./LICENSE`.
+
+## Support
+
+If you like what I do and you want to support me, feel free to donate to me on Ko-Fi.
+
+[<img src="https://codeberg.org/moxxy/moxxyv2/raw/branch/master/assets/repo/kofi.png" height="36" style="height: 36px; border: 0px;"></img>](https://ko-fi.com/papatutuwawa)

packages/moxxmpp_socket_tcp/lib/src/socket.dart

@@ -10,22 +10,31 @@ import 'package:moxxmpp_socket_tcp/src/rfc_2782.dart';
 
 /// TCP socket implementation for XmppConnection
 class TCPSocketWrapper extends BaseSocketWrapper {
-  TCPSocketWrapper(this._logData)
-  : _log = Logger('TCPSocketWrapper'),
-    _dataStream = StreamController.broadcast(),
-    _eventStream = StreamController.broadcast(),
-    _secure = false,
-    _ignoreSocketClosure = false;
+  TCPSocketWrapper(this._logData);
+
+  /// The underlying Socket/SecureSocket instance.
   Socket? _socket;
-  bool _ignoreSocketClosure;
-  final StreamController<String> _dataStream;
-  final StreamController<XmppSocketEvent> _eventStream;
+
+  /// Indicates that we expect a socket closure.
+  bool _expectSocketClosure = false;
+
+  /// The stream of incoming data from the socket.
+  final StreamController<String> _dataStream = StreamController.broadcast();
+
+  /// The stream of outgoing (TCPSocketWrapper -> XmppConnection) events.
+  final StreamController<XmppSocketEvent> _eventStream = StreamController.broadcast();
+
+  /// A subscription on the socket's data stream.
   StreamSubscription<dynamic>? _socketSubscription;
 
-  final Logger _log;
+  /// Logger
+  final Logger _log = Logger('TCPSocketWrapper');
+
+  /// Flag to indicate if incoming and outgoing data should get logged.
   final bool _logData;
 
-  bool _secure;
+  /// Indiacted whether the connection is secure.
+  bool _secure = false;
 
   @override
   bool isSecure() => _secure;
@@ -72,7 +81,6 @@ class TCPSocketWrapper extends BaseSocketWrapper {
     for (final srv in results) {
       try {
         _log.finest('Attempting secure connection to ${srv.target}:${srv.port}...');
-        _ignoreSocketClosure = true;
 
         // Workaround: We cannot set the SNI directly when using SecureSocket.connect.
         // instead, we connect using a regular socket and then secure it. This allows
@@ -89,13 +97,11 @@ class TCPSocketWrapper extends BaseSocketWrapper {
           onBadCertificate: (cert) => onBadCertificate(cert, domain),
         );
 
-        _ignoreSocketClosure = false;
         _secure = true;
         _log.finest('Success!');
         return true;
       } on Exception catch(e) {
         _log.finest('Failure! $e');
-        _ignoreSocketClosure = false;
 
         if (e is HandshakeException) {
           failedDueToTLS = true;
@@ -118,19 +124,16 @@ class TCPSocketWrapper extends BaseSocketWrapper {
     for (final srv in results) {
       try {
         _log.finest('Attempting connection to ${srv.target}:${srv.port}...');
-        _ignoreSocketClosure = true;
         _socket = await Socket.connect(
           srv.target,
           srv.port,
           timeout: const Duration(seconds: 5),
         );
 
-        _ignoreSocketClosure = false;
         _log.finest('Success!');
         return true;
       } on Exception catch(e) {
         _log.finest('Failure! $e');
-        _ignoreSocketClosure = false;
         continue;
       }
     }
@@ -144,7 +147,6 @@ class TCPSocketWrapper extends BaseSocketWrapper {
   Future<bool> _hostPortConnect(String host, int port) async {
     try {
       _log.finest('Attempting fallback connection to $host:$port...');
-      _ignoreSocketClosure = true;
       _socket = await Socket.connect(
         host,
         port,
@@ -154,7 +156,6 @@ class TCPSocketWrapper extends BaseSocketWrapper {
       return true;
     } on Exception catch(e) {
       _log.finest('Failure! $e');
-      _ignoreSocketClosure = false;
       return false;
     }
   }
@@ -179,10 +180,11 @@ class TCPSocketWrapper extends BaseSocketWrapper {
       _log.severe('Failed to secure socket since _socket is null');
       return false;
     }
-
-    _ignoreSocketClosure = true;
     
     try {
+      // The socket is closed during the entire process
+      _expectSocketClosure = true;
+
       _socket = await SecureSocket.secure(
         _socket!,
         supportedProtocols: const [ xmppClientALPNId ],
@@ -190,12 +192,10 @@ class TCPSocketWrapper extends BaseSocketWrapper {
       );
 
       _secure = true;
-      _ignoreSocketClosure = false;
       _setupStreams();
       return true;
     } on Exception catch (e) {
       _log.severe('Failed to secure socket: $e');
-      _ignoreSocketClosure = false;
 
       if (e is HandshakeException) {
         _eventStream.add(XmppSocketTLSFailedEvent());
@@ -226,15 +226,14 @@ class TCPSocketWrapper extends BaseSocketWrapper {
     );
     // ignore: implicit_dynamic_parameter
     _socket!.done.then((_) {
-      if (!_ignoreSocketClosure) {
-        _eventStream.add(XmppSocketClosureEvent());
-      }
+      _eventStream.add(XmppSocketClosureEvent(_expectSocketClosure));
+      _expectSocketClosure = false;
     });
   }
   
   @override
   Future<bool> connect(String domain, { String? host, int? port }) async {
-    _ignoreSocketClosure = false;
+    _expectSocketClosure = false;
     _secure = false;
 
     // Connection order:
@@ -267,6 +266,8 @@ class TCPSocketWrapper extends BaseSocketWrapper {
 
   @override
   void close() {
+    _expectSocketClosure = true;
+
     if (_socketSubscription != null) {
       _log.finest('Closing socket subscription');
       _socketSubscription!.cancel();
@@ -277,13 +278,11 @@ class TCPSocketWrapper extends BaseSocketWrapper {
       return;
     }
 
-    _ignoreSocketClosure = true;
     try {
       _socket!.close();
     } catch(e) {
       _log.warning('Closing socket threw exception: $e');
     }
-    _ignoreSocketClosure = false;
   }
 
   @override
@@ -316,7 +315,5 @@ class TCPSocketWrapper extends BaseSocketWrapper {
   }
 
   @override
-  void prepareDisconnect() {
-    _ignoreSocketClosure = true;
-  }
+  void prepareDisconnect() {}
 }