fix: use expiry from swarm to update readAt & expiresAt for msg

ts/models/message.ts

@@ -1157,26 +1157,18 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
   }
 
   public isExpired() {
-    return this.msTilExpire() <= 0;
-  }
-
-  public msTilExpire() {
     if (!this.isExpiring()) {
-      return Infinity;
+      return false;
     }
     const now = Date.now();
     const start = this.getExpirationStartTimestamp();
     if (!start) {
-      return Infinity;
+      return false;
     }
     const delta = this.getExpireTimer() * 1000;
-    let msFromNow = start + delta - now;
+    const msFromNow = start + delta - now;
-    if (msFromNow < 0) {
+    return msFromNow < 0;
-      msFromNow = 0;
-    }
-    return msFromNow;
   }
-
   public async setToExpire() {
     if (this.isExpiring() && !this.getExpiresAt()) {
       const start = this.getExpirationStartTimestamp();

ts/models/messageType.ts

@@ -31,6 +31,7 @@ export interface MessageAttributes {
   expirationType?: DisappearingMessageType;
   /** in seconds, 0 means no expiration */
   expireTimer: number;
+  /** in milliseconds */
   expirationStartTimestamp: number;
   expires_at?: number;
   expirationTimerUpdate?: ExpirationTimerUpdate;

ts/session/apis/snode_api/expireRequest.ts

@@ -148,8 +148,8 @@ export async function processExpireRequestResponse(
   return results;
 }
 
-type UpdatedExpiryWithHashes = { messageHashes: Array<string>; updatedExpiry: number };
+type UpdatedExpiryWithHashes = { messageHashes: Array<string>; updatedExpiryMs: number };
-type UpdatedExpiryWithHash = { messageHash: string; updatedExpiry: number };
+type UpdatedExpiryWithHash = { messageHash: string; updatedExpiryMs: number };
 
 async function updateExpiryOnNodes(
   targetNode: Snode,
@@ -210,7 +210,7 @@ async function updateExpiryOnNodes(
       }
       changesValid.push({
         messageHashes: expirationResult.hashes,
-        updatedExpiry: expirationResult.expiry,
+        updatedExpiryMs: expirationResult.expiry,
       });
     }
 
@@ -222,17 +222,16 @@ async function updateExpiryOnNodes(
       // we requested hashes which are not part of the result. They most likely expired already so let's mark those messages as expiring now.
       changesValid.push({
         messageHashes: hashesRequestedButNotInResults,
-        updatedExpiry: Date.now(),
+        updatedExpiryMs: Date.now(),
       });
     }
 
     const expiryWithIndividualHash: Array<UpdatedExpiryWithHash> = flatten(
       changesValid.map(change =>
-        change.messageHashes.map(h => ({ messageHash: h, updatedExpiry: change.updatedExpiry }))
+        change.messageHashes.map(h => ({ messageHash: h, updatedExpiryMs: change.updatedExpiryMs }))
       )
     );
-    debugger;
+    window.log.debug('update expiry expiryWithIndividualHash: ', expiryWithIndividualHash);
-    console.warn('update expiry expiryWithIndividualHash: ', expiryWithIndividualHash);
     return expiryWithIndividualHash;
   } catch (err) {
     // NOTE batch requests have their own retry logic which includes abort errors that will break our retry logic so we need to catch them and throw regular errors
@@ -373,7 +372,7 @@ export type ExpiringDetails = Array<
 export async function expireMessagesOnSnode(
   expiringDetails: ExpiringDetails,
   options: WithShortenOrExtend
-): Promise<Array<{ messageHash: string; updatedExpiry: number }>> {
+): Promise<Array<{ messageHash: string; updatedExpiryMs: number }>> {
   const ourPubKey = UserUtils.getOurPubKeyStrFromCache();
   if (!ourPubKey) {
     throw new Error('[expireMessageOnSnode] No pubkey found');

ts/session/disappearing_messages/index.ts

@@ -79,10 +79,22 @@ async function destroyExpiredMessages() {
     messages.forEach(expired => {
       window.log.info('Message expired', {
         sentAt: expired.get('sent_at'),
+        hash: expired.getMessageHash(),
       });
     });
 
     await destroyMessagesAndUpdateRedux(messagesExpiredDetails);
+    const convosToRefresh = uniq(messagesExpiredDetails.map(m => m.conversationKey));
+    await Promise.all(
+      convosToRefresh.map(async c => {
+        getConversationController()
+          .get(c)
+          ?.updateLastMessage();
+        return getConversationController()
+          .get(c)
+          ?.refreshInMemoryDetails();
+      })
+    );
   } catch (error) {
     window.log.error(
       'destroyExpiredMessages: Error deleting expired messages',
@@ -552,7 +564,7 @@ async function updateMessageExpiriesOnSwarm(messages: Array<MessageModel>) {
     window.log.debug(`[updateMessageExpiriesOnSwarm] no expiringDetails to update`);
     return;
   }
-  console.warn('expiringDetails', expiringDetails);
+  window.log.debug('updateMessageExpiriesOnSwarm: expiringDetails', expiringDetails);
 
   const newTTLs = await expireMessagesOnSnode(expiringDetails, { shortenOrExtend: 'shorten' });
   const updatedMsgModels: Array<MessageModel> = [];
@@ -562,10 +574,23 @@ async function updateMessageExpiriesOnSwarm(messages: Array<MessageModel>) {
       return;
     }
 
-    const newTTL = m.updatedExpiry;
+    const newTTLms = m.updatedExpiryMs;
-    if (newTTL && newTTL !== message.getExpiresAt()) {
+    const realReadAt = newTTLms - message.getExpireTimer() * 1000;
+    if (
+      newTTLms &&
+      (newTTLms !== message.getExpiresAt() ||
+        message.get('expirationStartTimestamp') !== realReadAt) &&
+      message.getExpireTimer()
+    ) {
+      window.log.debug(`updateMessageExpiriesOnSwarm: setting for msg hash ${m.messageHash}:`, {
+        expires_at: newTTLms,
+        expirationStartTimestamp: realReadAt,
+        unread: READ_MESSAGE_STATE.read,
+      });
       message.set({
-        expires_at: newTTL,
+        expires_at: newTTLms,
+        expirationStartTimestamp: realReadAt,
+        unread: READ_MESSAGE_STATE.read,
       });
 
       updatedMsgModels.push(message);

ts/session/utils/job_runners/jobs/FetchMsgExpirySwarmJob.ts

@@ -2,6 +2,7 @@
 import { compact, isEmpty, isNumber, uniq } from 'lodash';
 import { v4 } from 'uuid';
 import { Data } from '../../../../data/data';
+import { READ_MESSAGE_STATE } from '../../../../models/conversationAttributes';
 import { MessageModel } from '../../../../models/message';
 import { isSignInByLinking } from '../../../../util/storage';
 import { getExpiriesFromSnode } from '../../../apis/snode_api/getExpiriesRequest';
@@ -66,13 +67,31 @@ class FetchMsgExpirySwarmJob extends PersistedJob<FetchMsgExpirySwarmPersistedDa
           if (expiry.fetchedExpiry <= 0) {
             continue;
           }
-          const found = msgModels.find(m => m.getMessageHash() === expiry.messageHash);
+          const message = msgModels.find(m => m.getMessageHash() === expiry.messageHash);
-          if (!found) {
+          if (!message) {
             continue;
           }
-          if (found.get('expires_at') !== expiry.fetchedExpiry) {
+          const realReadAt = expiry.fetchedExpiry - message.getExpireTimer() * 1000;
-            found.set('expires_at', expiry.fetchedExpiry);
+
-            updatedMsgModels.push(found);
+          if (
+            (message.get('expirationStartTimestamp') !== realReadAt ||
+              message.get('expires_at') !== expiry.fetchedExpiry) &&
+            message.getExpireTimer()
+          ) {
+            window.log.debug(
+              `FetchMsgExpirySwarmJob: setting for msg hash ${message.getMessageHash()}:`,
+              {
+                expires_at: expiry.fetchedExpiry,
+                unread: READ_MESSAGE_STATE.read,
+                expirationStartTimestamp: realReadAt,
+              }
+            );
+            message.set({
+              expires_at: expiry.fetchedExpiry,
+              unread: READ_MESSAGE_STATE.read,
+              expirationStartTimestamp: realReadAt,
+            });
+            updatedMsgModels.push(message);
           }
         }
       }