fix: read receipt and DaS/DaR logic

Author: Bilb

ts/models/conversation.ts

@@ -203,14 +203,14 @@ export class ConversationModel extends Model<ConversationAttributes> {
     const type = this.get('type');
     switch (type) {
       case ConversationTypeEnum.PRIVATE:
-        return this.id;
+        return `priv:${ed25519Str(this.id)}`;
       case ConversationTypeEnum.GROUPV2:
-        return `group(${ed25519Str(this.id)})`;
+        return `group:${ed25519Str(this.id)}`;
       case ConversationTypeEnum.GROUP: {
         if (this.isPublic()) {
-          return this.id;
+          return `comm:${this.id}`;
         }
-        return `group(${ed25519Str(this.id)})`;
+        return `group_legacy:${ed25519Str(this.id)}`;
       }
       default:
         assertUnreachable(type, `idForLogging case not handled for type:"${type}"`);
@@ -815,10 +815,7 @@ export class ConversationModel extends Model<ConversationAttributes> {
     const networkTimestamp = NetworkTime.now();
 
     window?.log?.info(
-      'Sending message to conversation',
-      this.idForLogging(),
-      'with networkTimestamp: ',
-      networkTimestamp
+      `Sending message to conversation ${this.idForLogging()} with networkTimestamp: ${networkTimestamp}`
     );
 
     const attachmentsWithVoiceMessage = attachments
@@ -1012,11 +1009,12 @@ export class ConversationModel extends Model<ConversationAttributes> {
       }
     }
 
-    // Note: we agreed that a **legacy closed** group ControlMessage message does not expire.
-    // Group v2 on the other hand, have expiring disappearing control message
+    // Private chats and group v2 are the two types of conversation
+    // where this function can be called, and both have expiring
+    // disappearing control messages.
     message.set({
-      expirationType: this.isClosedGroup() && !this.isClosedGroupV2() ? 'unknown' : expirationType,
-      expireTimer: this.isClosedGroup() && !this.isClosedGroupV2() ? 0 : expireTimer,
+      expirationType,
+      expireTimer,
     });
 
     if (!message.id) {

ts/models/message.ts

@@ -8,6 +8,7 @@ import { ContentMessage } from '../session/messages/outgoing';
 import { ClosedGroupV2VisibleMessage } from '../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
 import { PubKey } from '../session/types';
 import {
+  MessageUtils,
   UserUtils,
   attachmentIdAsStrFromUrl,
   uploadAttachmentsToFileServer,
@@ -89,7 +90,7 @@ import {
   getPromotedGroupUpdateChangeStr,
 } from './groupUpdate';
 import { NetworkTime } from '../util/NetworkTime';
-import { MessageQueue } from '../session/sending';
+import { MessageQueue, MessageSender } from '../session/sending';
 import { getTimerNotificationStr } from './timerNotifications';
 import { ExpirationTimerUpdate } from '../session/disappearing_messages/types';
 import { Model } from './models';
@@ -170,7 +171,7 @@ export class MessageModel extends Model<MessageAttributes> {
   }
 
   public idForLogging() {
-    return `${this.get('source')} ${this.get('sent_at')}`;
+    return `msg(${this.id}, ${this.getConversation()?.idForLogging()}, ${this.get('sent_at')})`;
   }
 
   public isExpirationTimerUpdate() {
@@ -1087,9 +1088,14 @@ export class MessageModel extends Model<MessageAttributes> {
       );
 
       if (syncMessage) {
-        await MessageQueue.use().sendSyncMessage({
-          namespace: SnodeNamespaces.Default,
-          message: syncMessage,
+        await MessageSender.sendSingleMessage({
+          isSyncMessage: true,
+          message: await MessageUtils.toRawMessage(
+            PubKey.cast(UserUtils.getOurPubKeyStrFromCache()),
+            syncMessage,
+            SnodeNamespaces.Default
+          ),
+          abortSignal: null,
         });
       }
     }

ts/models/messageFactory.ts

@@ -83,6 +83,7 @@ function getSharedAttributesForPublicMessage({
     messageHash: '', // we do not care of a messageHash for an opengroup message. we have serverId for that
     // NOTE Community messages do not support disappearing messages
     expirationStartTimestamp: undefined,
+    expires_at: undefined,
   };
 }
 

ts/receiver/queuedJob.ts

@@ -379,7 +379,7 @@ async function markConvoAsReadIfOutgoingMessage(
   const isOutgoingMessage =
     message.get('type') === 'outgoing' || message.get('direction') === 'outgoing';
   if (isOutgoingMessage) {
-    const sentAt = message.get('sent_at') || message.get('serverTimestamp');
+    const sentAt = message.get('serverTimestamp') || message.get('sent_at');
     if (sentAt) {
       const expirationType = message.getExpirationType();
       const expireTimer = message.getExpireTimerSeconds();
@@ -446,16 +446,21 @@ export async function handleMessageJob(
         messageModel.getExpirationType(),
         messageModel.getExpireTimerSeconds()
       );
-
-      if (expirationMode === 'deleteAfterSend') {
-        messageModel.set({
-          expirationStartTimestamp: DisappearingMessages.setExpirationStartTimestamp(
-            expirationMode,
-            messageModel.get('sent_at'),
-            'handleMessageJob',
-            messageModel.id
-          ),
-        });
+      const expireTimer = messageModel.getExpireTimerSeconds();
+
+      if (expirationMode === 'deleteAfterSend' && expireTimer > 0) {
+        const expirationStartTimestamp = DisappearingMessages.setExpirationStartTimestamp(
+          expirationMode,
+          messageModel.get('sent_at'),
+          'handleMessageJob',
+          messageModel.id
+        );
+        if (expirationStartTimestamp) {
+          messageModel.set({
+            expirationStartTimestamp,
+            expires_at: expirationStartTimestamp + expireTimer * 1000,
+          });
+        }
       }
     }
 

ts/session/disappearing_messages/index.ts

@@ -170,7 +170,7 @@ function setExpirationStartTimestamp(
   // these are for debugging purposes
   callLocation?: string,
   messageId?: string
-): number | undefined {
+) {
   let expirationStartTimestamp: number | undefined = NetworkTime.now();
 
   if (callLocation) {
@@ -184,7 +184,7 @@ function setExpirationStartTimestamp(
   if (timestamp) {
     if (!isValidUnixTimestamp(timestamp)) {
       window.log.debug(
-        `[setExpirationStartTimestamp] We compared 2 timestamps for a disappearing message (${mode}) and the argument timestamp is not a invalid unix timestamp.${
+        `[setExpirationStartTimestamp] We compared 2 timestamps for a disappearing message (${mode}) and the argument timestamp is an invalid unix timestamp.${
           messageId ? `messageId: ${messageId} ` : ''
         }`
       );
@@ -361,7 +361,15 @@ async function checkForExpireUpdateInContentMessage(
 /**
  * Checks if an outgoing message is meant to disappear and if so trigger the timer
  */
-function checkForExpiringOutgoingMessage(message: MessageModel, location?: string) {
+function checkForExpiringOutgoingMessage({
+  effectivelyStoredAtMs,
+  location,
+  message,
+}: {
+  message: MessageModel;
+  location: string;
+  effectivelyStoredAtMs: number;
+}) {
   const convo = message.getConversation();
   const expireTimer = message.getExpireTimerSeconds();
   const expirationType = message.getExpirationType();
@@ -379,13 +387,17 @@ function checkForExpiringOutgoingMessage(message: MessageModel, location?: strin
     const expirationMode = changeToDisappearingConversationMode(convo, expirationType, expireTimer);
 
     if (expirationMode !== 'off') {
-      message.set({
-        expirationStartTimestamp: setExpirationStartTimestamp(
-          expirationMode,
-          message.get('sent_at'),
-          location
-        ),
-      });
+      const expirationStartTimestamp = setExpirationStartTimestamp(
+        expirationMode,
+        effectivelyStoredAtMs,
+        location
+      );
+      if (expirationStartTimestamp) {
+        message.set({
+          expirationStartTimestamp,
+          expires_at: expirationStartTimestamp + expireTimer * 1000,
+        });
+      }
     }
   }
 }
@@ -499,14 +511,17 @@ function getMessageReadyToDisappear(
     messageExpirationFromRetrieve > 0
   ) {
     // Note: closed groups control message do not disappear
-    if (!conversationModel.isClosedGroup() && !messageModel.isControlMessage()) {
-      const expirationStartTimestamp = messageExpirationFromRetrieve - expireTimer * 1000;
-      const expires_at = messageExpirationFromRetrieve;
-      messageModel.set({
-        expirationStartTimestamp,
-        expires_at,
-      });
-    }
+
+    const expirationStartTimestamp = messageExpirationFromRetrieve - expireTimer * 1000;
+    const expires_at = messageExpirationFromRetrieve;
+
+    window.log.debug(
+      `incoming DaS message,\n\tforcing expirationStartTimestamp to ${expirationStartTimestamp} which is ${(Date.now() - expirationStartTimestamp) / 1000}s ago,\n\tand expires_at to ${expires_at} so with ${(messageExpirationFromRetrieve - Date.now()) / 1000}s left`
+    );
+    messageModel.set({
+      expirationStartTimestamp,
+      expires_at,
+    });
   }
 
   return messageModel;

ts/session/sending/MessageSender.ts

@@ -673,7 +673,7 @@ async function handleBatchResultWithSubRequests({
     // there are some things we need to do when storing messages
     // for groups/legacy groups or user (but not for config messages)
     if (isStoreUserInitiatedSubRequest(subRequest)) {
-      const storedAt = batchResult?.[index]?.body?.t;
+      const storedAtMs = batchResult?.[index]?.body?.t;
       const storedHash = batchResult?.[index]?.body?.hash;
       const subRequestStatusCode = batchResult?.[index]?.code;
       // TODO: the expiration is due to be returned by the storage server on "store" soon, we will then be able to use it instead of doing the storedAt + ttl logic below
@@ -682,7 +682,7 @@ async function handleBatchResultWithSubRequests({
         subRequestStatusCode === 200 &&
         !isEmpty(storedHash) &&
         isString(storedHash) &&
-        isNumber(storedAt)
+        isNumber(storedAtMs)
       ) {
         seenHashes.push({
           expiresAt: NetworkTime.now() + TTL_DEFAULT.CONTENT_MESSAGE, // non config msg expire at CONTENT_MESSAGE at most
@@ -694,19 +694,18 @@ async function handleBatchResultWithSubRequests({
         // For groups, we can just store that hash directly as the group's swarm is hosting all of the group messages
         if (subRequest.dbMessageIdentifier) {
           // eslint-disable-next-line no-await-in-loop
-          await MessageSentHandler.handleSwarmMessageSentSuccess(
-            {
-              device: subRequest.destination,
-              isDestinationClosedGroup: MessageSender.destinationIsClosedGroup(destination),
-              identifier: subRequest.dbMessageIdentifier,
-              plainTextBuffer:
-                subRequest instanceof StoreUserMessageSubRequest
-                  ? subRequest.plainTextBuffer
-                  : null,
-            },
-            storedAt,
-            storedHash
-          );
+          await MessageSentHandler.handleSwarmMessageSentSuccess({
+            device: subRequest.destination,
+            isDestinationClosedGroup: MessageSender.destinationIsClosedGroup(destination),
+            identifier: subRequest.dbMessageIdentifier,
+            plainTextBuffer:
+              subRequest instanceof StoreUserMessageSubRequest ? subRequest.plainTextBuffer : null,
+            // Note: we cannot override this effective timestamp, as this is the one used as an id for
+            // quotes and read receipts.
+            sentAtMs: subRequest.createdAtNetworkTimestamp,
+            storedAtServerMs: storedAtMs,
+            storedHash,
+          });
         }
       }
     }

ts/session/sending/MessageSentHandler.ts

@@ -59,26 +59,39 @@ async function handlePublicMessageSentFailure(sentMessage: OpenGroupVisibleMessa
   await fetchedMessage.getConversation()?.updateLastMessage();
 }
 
-async function handleSwarmMessageSentSuccess(
-  {
-    device: destination,
-    identifier,
-    isDestinationClosedGroup,
-    plainTextBuffer,
-  }: Pick<OutgoingRawMessage, 'device' | 'identifier'> & {
-    /**
-     * plainTextBuffer is only required when sending a message to a 1o1,
-     * as we need it to encrypt it again for our linked devices (synced messages)
-     */
-    plainTextBuffer: Uint8Array | null;
-    /**
-     * We must not sync a message when it was sent to a closed group
-     */
-    isDestinationClosedGroup: boolean;
-  },
-  effectiveTimestamp: number,
-  storedHash: string | null
-) {
+async function handleSwarmMessageSentSuccess({
+  device: destination,
+  identifier,
+  isDestinationClosedGroup,
+  plainTextBuffer,
+  sentAtMs,
+  storedAtServerMs,
+  storedHash,
+}: Pick<OutgoingRawMessage, 'device' | 'identifier'> & {
+  /**
+   * plainTextBuffer is only required when sending a message to a 1o1,
+   * as we need it to encrypt it again for our linked devices (synced messages)
+   */
+  plainTextBuffer: Uint8Array | null;
+  /**
+   * We must not sync a message when it was sent to a closed group
+   */
+  isDestinationClosedGroup: boolean;
+  /**
+   * The timestamp when the message was reported as stored at by the server.
+   * This is the one we should use to start the disappearing message timer.
+   */
+  storedAtServerMs: number;
+  /**
+   * The timestamp when the message was built locally, i.e. how it will be ordered.
+   * This timestamp is also used for read receipts identification and quotes.
+   */
+  sentAtMs: number;
+  /**
+   * The hash of the message as reported by the server.
+   */
+  storedHash: string | null;
+}) {
   // The wrappedEnvelope will be set only if the message is not one of OpenGroupV2Message type.
   let fetchedMessage = await fetchHandleMessageSentData(identifier);
   if (!fetchedMessage) {
@@ -102,16 +115,16 @@ async function handleSwarmMessageSentSuccess(
 
   // A message is synced if we triggered a sync message (sentSync)
   // and the current message was sent to our device (so a sync message)
-  const shouldMarkMessageAsSynced =
-    (isOurDevice && fetchedMessage.get('sentSync')) || isClosedGroupMessage;
+  const isPrivateSyncMessage = isOurDevice && fetchedMessage.get('sentSync');
+  const shouldMarkMessageAsSynced = isPrivateSyncMessage || isClosedGroupMessage;
 
   // Handle the sync logic here
   if (shouldTriggerSyncMessage && plainTextBuffer) {
     try {
       const contentDecoded = SignalService.Content.decode(plainTextBuffer);
       if (contentDecoded && contentDecoded.dataMessage) {
         try {
-          await fetchedMessage.sendSyncMessage(contentDecoded, effectiveTimestamp);
+          await fetchedMessage.sendSyncMessage(contentDecoded, sentAtMs);
           const tempFetchMessage = await fetchHandleMessageSentData(identifier);
           if (!tempFetchMessage) {
             window?.log?.warn(
@@ -141,11 +154,17 @@ async function handleSwarmMessageSentSuccess(
   fetchedMessage.set({
     sent_to: sentTo,
     sent: true,
-    sent_at: effectiveTimestamp,
+    sent_at: sentAtMs,
     errors: undefined,
   });
 
-  DisappearingMessages.checkForExpiringOutgoingMessage(fetchedMessage, 'handleMessageSentSuccess');
+  if (!isPrivateSyncMessage) {
+    DisappearingMessages.checkForExpiringOutgoingMessage({
+      message: fetchedMessage,
+      location: 'handleSwarmMessageSentSuccess',
+      effectivelyStoredAtMs: storedAtServerMs,
+    });
+  }
 
   await fetchedMessage.commit();
   fetchedMessage.getConversation()?.updateLastMessage();
@@ -182,6 +201,7 @@ async function handleSwarmMessageSentFailure(
   if (fetchedMessage.getExpirationType() && fetchedMessage.getExpireTimerSeconds() > 0) {
     fetchedMessage.set({
       expirationStartTimestamp: undefined,
+      expires_at: undefined,
     });
     window.log.warn(
       `[handleSwarmMessageSentFailure] Stopping a message from disappearing until we retry the send operation. messageId: ${fetchedMessage.get(

ts/session/utils/Attachments.ts

@@ -108,7 +108,7 @@ export async function uploadLinkPreviewToFileServer(
   // some links do not have an image associated, and it makes the whole message fail to send
   if (!preview?.image) {
     if (!preview) {
-      window.log.warn('tried to upload file to FileServer without image.. skipping');
+      window.log.debug('tried to upload file to FileServer without image.. skipping');
     }
     return preview as any;
   }