diff --git a/keyserver/flow-typed/npm/@parse/node-apn_vx.x.x.js b/keyserver/flow-typed/npm/@parse/node-apn_vx.x.x.js
index 7dd236617..d0408dee1 100644
--- a/keyserver/flow-typed/npm/@parse/node-apn_vx.x.x.js
+++ b/keyserver/flow-typed/npm/@parse/node-apn_vx.x.x.js
@@ -1,452 +1,452 @@
 // flow-typed signature: 4d21eb714d444d66969e90089d6dd605
 // flow-typed version: <<STUB>>/@parse/node-apn_v3.2.0/flow_v0.137.0
 
 /**
  * This is an autogenerated libdef stub for:
  *
  *   '@parse/node-apn'
  *
  * Fill this stub out by replacing all the `any` types.
  *
  * Once filled out, we encourage you to share your work with the
  * community by sending a pull request to:
  * https://github.com/flowtype/flow-typed
  */
 
 declare module '@parse/node-apn' {
   declare type NotificationPushType = 'background' | 'alert' | 'voip';
   declare export class Notification {
     constructor(): this;
     length(): number;
     body: string;
     topic: string;
     id: string;
     expiry: number;
     priority: number;
     collapseId: string;
     pushType: NotificationPushType;
     threadId: string;
     payload: any;
     badge: ?number;
     sound: string;
     contentAvailable: boolean;
     mutableContent: boolean;
     urlArgs: string[];
     // Detailed explanation of this field can be found here:
     // https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/generating_a_remote_notification?language=objc#2943363
     // More fields can be added here, if they ever need to 
     // be accessed from apn.Notification instance
     aps: {
       +badge: string | number,
-      +alert: string,
+      +alert: string | { +body?: string, ... },
       +'thread-id': string,
       +'mutable-content': boolean,
       +sound: string,
       ...
     };
   }
 
   declare type ProviderToken = {|
     +key: string,
     +keyId: string,
     +teamId: string,
   |};
   declare export type ProviderOptions = {
     +token?: ProviderToken,
     +production?: boolean,
     ...
   };
 
   declare export type ResponseSent = {|
     +device: string,
   |};
   declare export type ResponseFailure = {|
     +device: string,
     +error?: ?Error,
     +status?: ?number,
     +response: {|
       +reason: string,
       +timestamp?: ?string,
     |},
   |};
   declare type Responses = {|
     +sent: $ReadOnlyArray<ResponseSent>,
     +failed: $ReadOnlyArray<ResponseFailure>,
   |};
 
   declare export class Provider extends events$EventEmitter {
     constructor(options: ProviderOptions): this;
     send(
       notification: Notification,
       recipients: string | $ReadOnlyArray<string>,
     ): Promise<Responses>;
     shutdown(): void;
   }
 
   declare export default {
     +Notification: typeof Notification,
     +Provider: typeof Provider,
     ...
   };
 }
 
 /**
  * We include stubs for each file inside this npm package in case you need to
  * require those files directly. Feel free to delete any files that aren't
  * needed.
  */
 declare module '@parse/node-apn/examples/sending-multiple-notifications' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/examples/sending-to-multiple-devices' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/client' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/config' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/ca/prepare' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/APNCertificate' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/APNKey' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/load' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/oids' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/parse' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/parsePemCertificate' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/parsePemKey' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/parsePkcs12' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/prepare' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/certificate/validate' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/resolve' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/credentials/token/prepare' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/notification/apsProperties' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/notification' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/protocol/endpoint' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/protocol/endpointManager' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/provider' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/token' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/lib/util/extend' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/mock/client' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/mock' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/client' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/config' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/ca/prepare' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/APNCertificate' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/APNKey' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/load' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/parse' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/parsePemCertificate' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/parsePemKey' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/parsePkcs12' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/prepare' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/certificate/validate' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/resolve' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/credentials/token/prepare' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/notification/apsProperties' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/notification' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/protocol/endpoint' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/protocol/endpointManager' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/provider' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/support' {
   declare module.exports: any;
 }
 
 declare module '@parse/node-apn/test/token' {
   declare module.exports: any;
 }
 
 // Filename aliases
 declare module '@parse/node-apn/examples/sending-multiple-notifications.js' {
   declare module.exports: $Exports<'@parse/node-apn/examples/sending-multiple-notifications'>;
 }
 declare module '@parse/node-apn/examples/sending-to-multiple-devices.js' {
   declare module.exports: $Exports<'@parse/node-apn/examples/sending-to-multiple-devices'>;
 }
 declare module '@parse/node-apn/index' {
   declare module.exports: $Exports<'@parse/node-apn'>;
 }
 declare module '@parse/node-apn/index.js' {
   declare module.exports: $Exports<'@parse/node-apn'>;
 }
 declare module '@parse/node-apn/lib/client.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/client'>;
 }
 declare module '@parse/node-apn/lib/config.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/config'>;
 }
 declare module '@parse/node-apn/lib/credentials/ca/prepare.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/ca/prepare'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/APNCertificate.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/APNCertificate'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/APNKey.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/APNKey'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/load.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/load'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/oids.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/oids'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/parse.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/parse'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/parsePemCertificate.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/parsePemCertificate'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/parsePemKey.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/parsePemKey'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/parsePkcs12.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/parsePkcs12'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/prepare.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/prepare'>;
 }
 declare module '@parse/node-apn/lib/credentials/certificate/validate.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/certificate/validate'>;
 }
 declare module '@parse/node-apn/lib/credentials/index' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials'>;
 }
 declare module '@parse/node-apn/lib/credentials/index.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials'>;
 }
 declare module '@parse/node-apn/lib/credentials/resolve.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/resolve'>;
 }
 declare module '@parse/node-apn/lib/credentials/token/prepare.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/credentials/token/prepare'>;
 }
 declare module '@parse/node-apn/lib/notification/apsProperties.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/notification/apsProperties'>;
 }
 declare module '@parse/node-apn/lib/notification/index' {
   declare module.exports: $Exports<'@parse/node-apn/lib/notification'>;
 }
 declare module '@parse/node-apn/lib/notification/index.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/notification'>;
 }
 declare module '@parse/node-apn/lib/protocol/endpoint.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/protocol/endpoint'>;
 }
 declare module '@parse/node-apn/lib/protocol/endpointManager.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/protocol/endpointManager'>;
 }
 declare module '@parse/node-apn/lib/provider.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/provider'>;
 }
 declare module '@parse/node-apn/lib/token.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/token'>;
 }
 declare module '@parse/node-apn/lib/util/extend.js' {
   declare module.exports: $Exports<'@parse/node-apn/lib/util/extend'>;
 }
 declare module '@parse/node-apn/mock/client.js' {
   declare module.exports: $Exports<'@parse/node-apn/mock/client'>;
 }
 declare module '@parse/node-apn/mock/index' {
   declare module.exports: $Exports<'@parse/node-apn/mock'>;
 }
 declare module '@parse/node-apn/mock/index.js' {
   declare module.exports: $Exports<'@parse/node-apn/mock'>;
 }
 declare module '@parse/node-apn/test/client.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/client'>;
 }
 declare module '@parse/node-apn/test/config.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/config'>;
 }
 declare module '@parse/node-apn/test/credentials/ca/prepare.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/ca/prepare'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/APNCertificate.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/APNCertificate'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/APNKey.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/APNKey'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/load.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/load'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/parse.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/parse'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/parsePemCertificate.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/parsePemCertificate'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/parsePemKey.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/parsePemKey'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/parsePkcs12.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/parsePkcs12'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/prepare.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/prepare'>;
 }
 declare module '@parse/node-apn/test/credentials/certificate/validate.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/certificate/validate'>;
 }
 declare module '@parse/node-apn/test/credentials/resolve.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/resolve'>;
 }
 declare module '@parse/node-apn/test/credentials/token/prepare.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/credentials/token/prepare'>;
 }
 declare module '@parse/node-apn/test/notification/apsProperties.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/notification/apsProperties'>;
 }
 declare module '@parse/node-apn/test/notification/index' {
   declare module.exports: $Exports<'@parse/node-apn/test/notification'>;
 }
 declare module '@parse/node-apn/test/notification/index.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/notification'>;
 }
 declare module '@parse/node-apn/test/protocol/endpoint.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/protocol/endpoint'>;
 }
 declare module '@parse/node-apn/test/protocol/endpointManager.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/protocol/endpointManager'>;
 }
 declare module '@parse/node-apn/test/provider.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/provider'>;
 }
 declare module '@parse/node-apn/test/support.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/support'>;
 }
 declare module '@parse/node-apn/test/token.js' {
   declare module.exports: $Exports<'@parse/node-apn/test/token'>;
 }
diff --git a/keyserver/src/push/crypto.js b/keyserver/src/push/crypto.js
index 9727618e1..f59eec852 100644
--- a/keyserver/src/push/crypto.js
+++ b/keyserver/src/push/crypto.js
@@ -1,299 +1,318 @@
 // @flow
 
 import apn from '@parse/node-apn';
 import invariant from 'invariant';
 import _cloneDeep from 'lodash/fp/cloneDeep.js';
 
+import { NEXT_CODE_VERSION } from 'lib/shared/version-utils.js';
+
 import type {
   AndroidNotification,
   AndroidNotificationPayload,
   AndroidNotificationRescind,
   NotificationTargetDevice,
 } from './types.js';
 import { encryptAndUpdateOlmSession } from '../updaters/olm-session-updater.js';
 
 async function encryptIOSNotification(
   cookieID: string,
   notification: apn.Notification,
+  codeVersion?: ?number,
   notificationSizeValidator?: apn.Notification => boolean,
 ): Promise<{ +notification: apn.Notification, +payloadSizeExceeded: boolean }> {
   invariant(
     !notification.collapseId,
     'Collapsible notifications encryption currently not implemented',
   );
 
   const encryptedNotification = new apn.Notification();
 
   encryptedNotification.id = notification.id;
   encryptedNotification.payload.id = notification.id;
   encryptedNotification.topic = notification.topic;
   encryptedNotification.sound = notification.aps.sound;
   encryptedNotification.pushType = 'alert';
   encryptedNotification.mutableContent = true;
 
   const { id, ...payloadSansId } = notification.payload;
   const unencryptedPayload = {
     ...payloadSansId,
     badge: notification.aps.badge.toString(),
     merged: notification.body,
   };
 
   try {
     const unencryptedSerializedPayload = JSON.stringify(unencryptedPayload);
 
     let dbPersistCondition;
     if (notificationSizeValidator) {
       dbPersistCondition = ({ serializedPayload }) => {
         const notifCopy = _cloneDeep(encryptedNotification);
         notifCopy.payload.encryptedPayload = serializedPayload.body;
         return notificationSizeValidator(notifCopy);
       };
     }
     const {
       encryptedMessages: { serializedPayload },
       dbPersistConditionViolated,
     } = await encryptAndUpdateOlmSession(
       cookieID,
       'notifications',
       {
         serializedPayload: unencryptedSerializedPayload,
       },
       dbPersistCondition,
     );
 
     encryptedNotification.payload.encryptedPayload = serializedPayload.body;
+
+    if (
+      codeVersion &&
+      codeVersion >= NEXT_CODE_VERSION &&
+      codeVersion % 2 === 0
+    ) {
+      encryptedNotification.aps = {
+        alert: { body: 'ENCRYPTED' },
+        ...encryptedNotification.aps,
+      };
+    }
+
     return {
       notification: encryptedNotification,
       payloadSizeExceeded: !!dbPersistConditionViolated,
     };
   } catch (e) {
     console.log('Notification encryption failed: ' + e);
 
     encryptedNotification.body = notification.body;
     encryptedNotification.threadId = notification.payload.threadID;
     invariant(
       typeof notification.aps.badge === 'number',
       'Unencrypted notification must have badge as a number',
     );
     encryptedNotification.badge = notification.aps.badge;
 
     encryptedNotification.payload = {
       ...encryptedNotification.payload,
       ...notification.payload,
       encryptionFailed: 1,
     };
     return {
       notification: encryptedNotification,
       payloadSizeExceeded: notificationSizeValidator
         ? notificationSizeValidator(_cloneDeep(encryptedNotification))
         : false,
     };
   }
 }
 
 async function encryptAndroidNotificationPayload<T>(
   cookieID: string,
   unencryptedPayload: T,
   payloadSizeValidator?: (T | { +encryptedPayload: string }) => boolean,
 ): Promise<{
   +resultPayload: T | { +encryptedPayload: string },
   +payloadSizeExceeded: boolean,
 }> {
   try {
     const unencryptedSerializedPayload = JSON.stringify(unencryptedPayload);
     if (!unencryptedSerializedPayload) {
       return {
         resultPayload: unencryptedPayload,
         payloadSizeExceeded: payloadSizeValidator
           ? payloadSizeValidator(unencryptedPayload)
           : false,
       };
     }
 
     let dbPersistCondition;
     if (payloadSizeValidator) {
       dbPersistCondition = ({ serializedPayload }) =>
         payloadSizeValidator({ encryptedPayload: serializedPayload.body });
     }
 
     const {
       encryptedMessages: { serializedPayload },
       dbPersistConditionViolated,
     } = await encryptAndUpdateOlmSession(
       cookieID,
       'notifications',
       {
         serializedPayload: unencryptedSerializedPayload,
       },
       dbPersistCondition,
     );
     return {
       resultPayload: { encryptedPayload: serializedPayload.body },
       payloadSizeExceeded: !!dbPersistConditionViolated,
     };
   } catch (e) {
     console.log('Notification encryption failed: ' + e);
     const resultPayload = {
       encryptionFailed: '1',
       ...unencryptedPayload,
     };
     return {
       resultPayload,
       payloadSizeExceeded: payloadSizeValidator
         ? payloadSizeValidator(resultPayload)
         : false,
     };
   }
 }
 
 async function encryptAndroidNotification(
   cookieID: string,
   notification: AndroidNotification,
   notificationSizeValidator?: AndroidNotification => boolean,
 ): Promise<{
   +notification: AndroidNotification,
   +payloadSizeExceeded: boolean,
 }> {
   const { id, badgeOnly, ...unencryptedPayload } = notification.data;
   let payloadSizeValidator;
   if (notificationSizeValidator) {
     payloadSizeValidator = (
       payload: AndroidNotificationPayload | { +encryptedPayload: string },
     ) => {
       return notificationSizeValidator({ data: { id, badgeOnly, ...payload } });
     };
   }
   const { resultPayload, payloadSizeExceeded } =
     await encryptAndroidNotificationPayload(
       cookieID,
       unencryptedPayload,
       payloadSizeValidator,
     );
   return {
     notification: {
       data: {
         id,
         badgeOnly,
         ...resultPayload,
       },
     },
     payloadSizeExceeded,
   };
 }
 
 async function encryptAndroidNotificationRescind(
   cookieID: string,
   notification: AndroidNotificationRescind,
 ): Promise<AndroidNotificationRescind> {
   // We don't validate payload size for rescind
   // since they are expected to be small and
   // never exceed any FCM limit
   const { resultPayload } = await encryptAndroidNotificationPayload(
     cookieID,
     notification.data,
   );
   return {
     data: resultPayload,
   };
 }
 
 function prepareEncryptedIOSNotifications(
   devices: $ReadOnlyArray<NotificationTargetDevice>,
   notification: apn.Notification,
+  codeVersion?: ?number,
   notificationSizeValidator?: apn.Notification => boolean,
 ): Promise<
   $ReadOnlyArray<{
     +cookieID: string,
     +deviceToken: string,
     +notification: apn.Notification,
     +payloadSizeExceeded: boolean,
   }>,
 > {
   const notificationPromises = devices.map(
     async ({ cookieID, deviceToken }) => {
       const notif = await encryptIOSNotification(
         cookieID,
         notification,
+        codeVersion,
         notificationSizeValidator,
       );
       return { cookieID, deviceToken, ...notif };
     },
   );
   return Promise.all(notificationPromises);
 }
 
 function prepareEncryptedIOSNotificationRescind(
   devices: $ReadOnlyArray<NotificationTargetDevice>,
   notification: apn.Notification,
+  codeVersion?: ?number,
 ): Promise<
   $ReadOnlyArray<{
     +cookieID: string,
     +deviceToken: string,
     +notification: apn.Notification,
   }>,
 > {
   const notificationPromises = devices.map(
     async ({ deviceToken, cookieID }) => {
       const { notification: notif } = await encryptIOSNotification(
         cookieID,
         notification,
+        codeVersion,
       );
       return { deviceToken, cookieID, notification: notif };
     },
   );
   return Promise.all(notificationPromises);
 }
 
 function prepareEncryptedAndroidNotifications(
   devices: $ReadOnlyArray<NotificationTargetDevice>,
   notification: AndroidNotification,
   notificationSizeValidator?: (notification: AndroidNotification) => boolean,
 ): Promise<
   $ReadOnlyArray<{
     +cookieID: string,
     +deviceToken: string,
     +notification: AndroidNotification,
     +payloadSizeExceeded: boolean,
   }>,
 > {
   const notificationPromises = devices.map(
     async ({ deviceToken, cookieID }) => {
       const notif = await encryptAndroidNotification(
         cookieID,
         notification,
         notificationSizeValidator,
       );
       return { deviceToken, cookieID, ...notif };
     },
   );
   return Promise.all(notificationPromises);
 }
 
 function prepareEncryptedAndroidNotificationRescinds(
   devices: $ReadOnlyArray<NotificationTargetDevice>,
   notification: AndroidNotificationRescind,
 ): Promise<
   $ReadOnlyArray<{
     +cookieID: string,
     +deviceToken: string,
     +notification: AndroidNotificationRescind,
   }>,
 > {
   const notificationPromises = devices.map(
     async ({ deviceToken, cookieID }) => {
       const notif = await encryptAndroidNotificationRescind(
         cookieID,
         notification,
       );
       return { deviceToken, cookieID, notification: notif };
     },
   );
   return Promise.all(notificationPromises);
 }
 
 export {
   prepareEncryptedIOSNotifications,
   prepareEncryptedIOSNotificationRescind,
   prepareEncryptedAndroidNotifications,
   prepareEncryptedAndroidNotificationRescinds,
 };
diff --git a/keyserver/src/push/rescind.js b/keyserver/src/push/rescind.js
index f055e1975..d05172c1c 100644
--- a/keyserver/src/push/rescind.js
+++ b/keyserver/src/push/rescind.js
@@ -1,346 +1,351 @@
 // @flow
 
 import apn from '@parse/node-apn';
 import invariant from 'invariant';
 
 import type { PlatformDetails } from 'lib/types/device-types.js';
 import { threadSubscriptions } from 'lib/types/subscription-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import { tID } from 'lib/utils/validation-utils.js';
 
 import {
   prepareEncryptedAndroidNotificationRescinds,
   prepareEncryptedIOSNotificationRescind,
 } from './crypto.js';
 import { getAPNsNotificationTopic } from './providers.js';
 import type {
   NotificationTargetDevice,
   TargetedAndroidNotification,
   TargetedAPNsNotification,
 } from './types.js';
 import { apnPush, fcmPush } from './utils.js';
 import createIDs from '../creators/id-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
 import type { SQLStatementType } from '../database/types.js';
 import { validateOutput } from '../utils/validation-utils.js';
 
 type ParsedDelivery = {
   +platform: 'ios' | 'macos' | 'android',
   +codeVersion: ?number,
   +notificationID: string,
   +deviceTokens: $ReadOnlyArray<string>,
 };
 
 type ParsedDeliveries = { +[id: string]: $ReadOnlyArray<ParsedDelivery> };
 
 async function rescindPushNotifs(
   notifCondition: SQLStatementType,
   inputCountCondition?: SQLStatementType,
 ) {
   const notificationExtractString = `$.${threadSubscriptions.home}`;
   const visPermissionExtractString = `$.${threadPermissions.VISIBLE}.value`;
   const fetchQuery = SQL`
     SELECT n.id, n.user, n.thread, n.message, n.delivery, n.collapse_key, COUNT(
   `;
   fetchQuery.append(inputCountCondition ? inputCountCondition : SQL`m.thread`);
   fetchQuery.append(SQL`
       ) AS unread_count
     FROM notifications n
     LEFT JOIN memberships m ON m.user = n.user 
       AND m.last_message > m.last_read_message 
       AND m.role > 0 
       AND JSON_EXTRACT(subscription, ${notificationExtractString})
       AND JSON_EXTRACT(permissions, ${visPermissionExtractString})
     WHERE n.rescinded = 0 AND
   `);
   fetchQuery.append(notifCondition);
   fetchQuery.append(SQL` GROUP BY n.id, m.user`);
   const [fetchResult] = await dbQuery(fetchQuery);
 
   const allDeviceTokens = new Set();
   const parsedDeliveries: ParsedDeliveries = {};
 
   for (const row of fetchResult) {
     const rawDelivery = JSON.parse(row.delivery);
     const deliveries = Array.isArray(rawDelivery) ? rawDelivery : [rawDelivery];
     const id = row.id.toString();
 
     const rowParsedDeliveries = [];
 
     for (const delivery of deliveries) {
       if (
         delivery.iosID ||
         delivery.deviceType === 'ios' ||
         delivery.deviceType === 'macos'
       ) {
         const deviceTokens = delivery.iosDeviceTokens ?? delivery.deviceTokens;
         rowParsedDeliveries.push({
           notificationID: delivery.iosID,
           codeVersion: delivery.codeVersion,
           stateVersion: delivery.stateVersion,
           platform: delivery.deviceType ?? 'ios',
           deviceTokens,
         });
         deviceTokens.forEach(deviceToken => allDeviceTokens.add(deviceToken));
       } else if (delivery.androidID || delivery.deviceType === 'android') {
         const deviceTokens =
           delivery.androidDeviceTokens ?? delivery.deviceTokens;
         rowParsedDeliveries.push({
           notificationID: row.collapse_key ? row.collapse_key : id,
           codeVersion: delivery.codeVersion,
           stateVersion: delivery.stateVersion,
           platform: 'android',
           deviceTokens,
         });
         deviceTokens.forEach(deviceToken => allDeviceTokens.add(deviceToken));
       }
     }
     parsedDeliveries[id] = rowParsedDeliveries;
   }
   const deviceTokenToCookieID = await getDeviceTokenToCookieID(allDeviceTokens);
 
   const deliveryPromises = {};
   const notifInfo = {};
   const rescindedIDs = [];
 
   for (const row of fetchResult) {
     const id = row.id.toString();
     const threadID = row.thread.toString();
 
     notifInfo[id] = {
       userID: row.user.toString(),
       threadID,
       messageID: row.message.toString(),
     };
 
     for (const delivery of parsedDeliveries[id]) {
       let platformDetails: PlatformDetails = { platform: delivery.platform };
       if (delivery.codeVersion) {
         platformDetails = {
           ...platformDetails,
           codeVersion: delivery.codeVersion,
         };
       }
       if (delivery.stateVersion) {
         platformDetails = {
           ...platformDetails,
           stateVersion: delivery.stateVersion,
         };
       }
 
       if (delivery.platform === 'ios') {
         const devices = delivery.deviceTokens.map(deviceToken => ({
           deviceToken,
           cookieID: deviceTokenToCookieID[deviceToken],
         }));
         const deliveryPromise = (async () => {
           const targetedNotifications = await prepareIOSNotification(
             delivery.notificationID,
             row.unread_count,
             threadID,
             platformDetails,
             devices,
           );
           return await apnPush({
             targetedNotifications,
             platformDetails: {
               platform: 'ios',
               codeVersion: delivery.codeVersion,
             },
           });
         })();
         deliveryPromises[id] = deliveryPromise;
       } else if (delivery.platform === 'android') {
         const devices = delivery.deviceTokens.map(deviceToken => ({
           deviceToken,
           cookieID: deviceTokenToCookieID[deviceToken],
         }));
         const deliveryPromise = (async () => {
           const targetedNotifications = await prepareAndroidNotification(
             delivery.notificationID,
             row.unread_count,
             threadID,
             platformDetails,
             devices,
           );
           return await fcmPush({
             targetedNotifications,
             codeVersion: delivery.codeVersion,
           });
         })();
         deliveryPromises[id] = deliveryPromise;
       }
     }
     rescindedIDs.push(id);
   }
 
   const numRescinds = Object.keys(deliveryPromises).length;
   const promises = [promiseAll(deliveryPromises)];
   if (numRescinds > 0) {
     promises.push(createIDs('notifications', numRescinds));
   }
   if (rescindedIDs.length > 0) {
     const rescindQuery = SQL`
       UPDATE notifications SET rescinded = 1 WHERE id IN (${rescindedIDs})
     `;
     promises.push(dbQuery(rescindQuery));
   }
 
   const [deliveryResults, dbIDs] = await Promise.all(promises);
   const newNotifRows = [];
   if (numRescinds > 0) {
     invariant(dbIDs, 'dbIDs should be set');
     for (const rescindedID in deliveryResults) {
       const delivery = {};
       delivery.source = 'rescind';
       delivery.rescindedID = rescindedID;
       const { errors } = deliveryResults[rescindedID];
       if (errors) {
         delivery.errors = errors;
       }
       const dbID = dbIDs.shift();
       const { userID, threadID, messageID } = notifInfo[rescindedID];
       newNotifRows.push([
         dbID,
         userID,
         threadID,
         messageID,
         null,
         JSON.stringify([delivery]),
         1,
       ]);
     }
   }
   if (newNotifRows.length > 0) {
     const insertQuery = SQL`
       INSERT INTO notifications
         (id, user, thread, message, collapse_key, delivery, rescinded)
       VALUES ${newNotifRows}
     `;
     await dbQuery(insertQuery);
   }
 }
 
 async function getDeviceTokenToCookieID(
   deviceTokens: Set<string>,
 ): Promise<{ +[string]: string }> {
   if (deviceTokens.size === 0) {
     return {};
   }
   const deviceTokenToCookieID = {};
   const fetchCookiesQuery = SQL`
     SELECT id, device_token FROM cookies 
     WHERE device_token IN (${[...deviceTokens]})
   `;
   const [fetchResult] = await dbQuery(fetchCookiesQuery);
   for (const row of fetchResult) {
     deviceTokenToCookieID[row.device_token.toString()] = row.id.toString();
   }
   return deviceTokenToCookieID;
 }
 
 async function conditionallyEncryptNotification<T>(
   notification: T,
   codeVersion: ?number,
   devices: $ReadOnlyArray<NotificationTargetDevice>,
   encryptCallback: (
     devices: $ReadOnlyArray<NotificationTargetDevice>,
     notification: T,
+    codeVersion?: ?number,
   ) => Promise<
     $ReadOnlyArray<{
       +notification: T,
       +cookieID: string,
       +deviceToken: string,
     }>,
   >,
 ): Promise<$ReadOnlyArray<{ +deviceToken: string, +notification: T }>> {
   const shouldBeEncrypted = codeVersion && codeVersion >= 233;
   if (!shouldBeEncrypted) {
     return devices.map(({ deviceToken }) => ({
       notification,
       deviceToken,
     }));
   }
-  const notifications = await encryptCallback(devices, notification);
+  const notifications = await encryptCallback(
+    devices,
+    notification,
+    codeVersion,
+  );
   return notifications.map(({ deviceToken, notification: notif }) => ({
     deviceToken,
     notification: notif,
   }));
 }
 
 async function prepareIOSNotification(
   iosID: string,
   unreadCount: number,
   threadID: string,
   platformDetails: PlatformDetails,
   devices: $ReadOnlyArray<NotificationTargetDevice>,
 ): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
   threadID = validateOutput(platformDetails, tID, threadID);
   const { codeVersion } = platformDetails;
 
   const notification = new apn.Notification();
   notification.topic = getAPNsNotificationTopic({
     platform: 'ios',
     codeVersion,
   });
 
   if (codeVersion && codeVersion > 198) {
     notification.mutableContent = true;
     notification.pushType = 'alert';
     notification.badge = unreadCount;
   } else {
     notification.priority = 5;
     notification.contentAvailable = true;
     notification.pushType = 'background';
   }
   notification.payload =
     codeVersion && codeVersion > 135
       ? {
           backgroundNotifType: 'CLEAR',
           notificationId: iosID,
           setUnreadStatus: true,
           threadID,
         }
       : {
           managedAps: {
             action: 'CLEAR',
             notificationId: iosID,
           },
         };
   return await conditionallyEncryptNotification(
     notification,
     codeVersion,
     devices,
     prepareEncryptedIOSNotificationRescind,
   );
 }
 
 async function prepareAndroidNotification(
   notifID: string,
   unreadCount: number,
   threadID: string,
   platformDetails: PlatformDetails,
   devices: $ReadOnlyArray<NotificationTargetDevice>,
 ): Promise<$ReadOnlyArray<TargetedAndroidNotification>> {
   threadID = validateOutput(platformDetails, tID, threadID);
   const { codeVersion } = platformDetails;
 
   const notification = {
     data: {
       badge: unreadCount.toString(),
       rescind: 'true',
       rescindID: notifID,
       setUnreadStatus: 'true',
       threadID,
     },
   };
   return await conditionallyEncryptNotification(
     notification,
     codeVersion,
     devices,
     prepareEncryptedAndroidNotificationRescinds,
   );
 }
 
 export { rescindPushNotifs };
diff --git a/keyserver/src/push/send.js b/keyserver/src/push/send.js
index 165a66383..7c705a864 100644
--- a/keyserver/src/push/send.js
+++ b/keyserver/src/push/send.js
@@ -1,1455 +1,1458 @@
 // @flow
 
 import apn from '@parse/node-apn';
 import type { ResponseFailure } from '@parse/node-apn';
 import invariant from 'invariant';
 import _cloneDeep from 'lodash/fp/cloneDeep.js';
 import _flow from 'lodash/fp/flow.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _pickBy from 'lodash/fp/pickBy.js';
 import t from 'tcomb';
 import uuidv4 from 'uuid/v4.js';
 
 import { oldValidUsernameRegex } from 'lib/shared/account-utils.js';
 import { isMentioned } from 'lib/shared/mention-utils.js';
 import {
   createMessageInfo,
   sortMessageInfoList,
   shimUnsupportedRawMessageInfos,
 } from 'lib/shared/message-utils.js';
 import { messageSpecs } from 'lib/shared/messages/message-specs.js';
 import { notifTextsForMessageInfo } from 'lib/shared/notif-utils.js';
 import {
   rawThreadInfoFromServerThreadInfo,
   threadInfoFromRawThreadInfo,
 } from 'lib/shared/thread-utils.js';
 import type { Platform, PlatformDetails } from 'lib/types/device-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type MessageData,
 } from 'lib/types/message-types.js';
 import { rawMessageInfoValidator } from 'lib/types/message-types.js';
 import type {
   WebNotification,
   WNSNotification,
   ResolvedNotifTexts,
 } from 'lib/types/notif-types.js';
 import { resolvedNotifTextsValidator } from 'lib/types/notif-types.js';
 import type { ServerThreadInfo } from 'lib/types/thread-types.js';
 import { updateTypes } from 'lib/types/update-types-enum.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import { tID, tPlatformDetails, tShape } from 'lib/utils/validation-utils.js';
 
 import {
   prepareEncryptedIOSNotifications,
   prepareEncryptedAndroidNotifications,
 } from './crypto.js';
 import { getAPNsNotificationTopic } from './providers.js';
 import { rescindPushNotifs } from './rescind.js';
 import type {
   NotificationTargetDevice,
   TargetedAPNsNotification,
   TargetedAndroidNotification,
 } from './types.js';
 import {
   apnPush,
   fcmPush,
   getUnreadCounts,
   apnMaxNotificationPayloadByteSize,
   fcmMaxNotificationPayloadByteSize,
   wnsMaxNotificationPayloadByteSize,
   webPush,
   wnsPush,
   type WebPushError,
   type WNSPushError,
 } from './utils.js';
 import createIDs from '../creators/id-creator.js';
 import { createUpdates } from '../creators/update-creator.js';
 import { dbQuery, SQL, mergeOrConditions } from '../database/database.js';
 import type { CollapsableNotifInfo } from '../fetchers/message-fetchers.js';
 import { fetchCollapsableNotifs } from '../fetchers/message-fetchers.js';
 import { fetchServerThreadInfos } from '../fetchers/thread-fetchers.js';
 import { fetchUserInfos } from '../fetchers/user-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import { getENSNames } from '../utils/ens-cache.js';
 import { validateOutput } from '../utils/validation-utils.js';
 
 export type Device = {
   +platform: Platform,
   +deviceToken: string,
   +cookieID: string,
   +codeVersion: ?number,
   +stateVersion: ?number,
 };
 
 type PushUserInfo = {
   +devices: Device[],
   // messageInfos and messageDatas have the same key
   +messageInfos: RawMessageInfo[],
   +messageDatas: MessageData[],
 };
 type Delivery = PushDelivery | { collapsedInto: string };
 type NotificationRow = {
   +dbID: string,
   +userID: string,
   +threadID?: ?string,
   +messageID?: ?string,
   +collapseKey?: ?string,
   +deliveries: Delivery[],
 };
 export type PushInfo = { [userID: string]: PushUserInfo };
 
 async function sendPushNotifs(pushInfo: PushInfo) {
   if (Object.keys(pushInfo).length === 0) {
     return;
   }
 
   const [
     unreadCounts,
     { usersToCollapsableNotifInfo, serverThreadInfos, userInfos },
     dbIDs,
   ] = await Promise.all([
     getUnreadCounts(Object.keys(pushInfo)),
     fetchInfos(pushInfo),
     createDBIDs(pushInfo),
   ]);
 
   const deliveryPromises = [];
   const notifications: Map<string, NotificationRow> = new Map();
   for (const userID in usersToCollapsableNotifInfo) {
     const threadInfos = _flow(
       _mapValues((serverThreadInfo: ServerThreadInfo) => {
         const rawThreadInfo = rawThreadInfoFromServerThreadInfo(
           serverThreadInfo,
           userID,
         );
         if (!rawThreadInfo) {
           return null;
         }
         return threadInfoFromRawThreadInfo(rawThreadInfo, userID, userInfos);
       }),
       _pickBy(threadInfo => threadInfo),
     )(serverThreadInfos);
     for (const notifInfo of usersToCollapsableNotifInfo[userID]) {
       const hydrateMessageInfo = (rawMessageInfo: RawMessageInfo) =>
         createMessageInfo(rawMessageInfo, userID, userInfos, threadInfos);
       const newMessageInfos = [];
       const newRawMessageInfos = [];
       for (const newRawMessageInfo of notifInfo.newMessageInfos) {
         const newMessageInfo = hydrateMessageInfo(newRawMessageInfo);
         if (newMessageInfo) {
           newMessageInfos.push(newMessageInfo);
           newRawMessageInfos.push(newRawMessageInfo);
         }
       }
       if (newMessageInfos.length === 0) {
         continue;
       }
       const existingMessageInfos = notifInfo.existingMessageInfos
         .map(hydrateMessageInfo)
         .filter(Boolean);
       const allMessageInfos = sortMessageInfoList([
         ...newMessageInfos,
         ...existingMessageInfos,
       ]);
       const [firstNewMessageInfo, ...remainingNewMessageInfos] =
         newMessageInfos;
       const { threadID } = firstNewMessageInfo;
 
       const threadInfo = threadInfos[threadID];
       const updateBadge = threadInfo.currentUser.subscription.home;
       const displayBanner = threadInfo.currentUser.subscription.pushNotifs;
       const username = userInfos[userID] && userInfos[userID].username;
       const userWasMentioned =
         username &&
         threadInfo.currentUser.role &&
         oldValidUsernameRegex.test(username) &&
         newMessageInfos.some(newMessageInfo => {
           const unwrappedMessageInfo =
             newMessageInfo.type === messageTypes.SIDEBAR_SOURCE
               ? newMessageInfo.sourceMessage
               : newMessageInfo;
           return (
             unwrappedMessageInfo.type === messageTypes.TEXT &&
             isMentioned(username, unwrappedMessageInfo.text)
           );
         });
       if (!updateBadge && !displayBanner && !userWasMentioned) {
         continue;
       }
       const badgeOnly = !displayBanner && !userWasMentioned;
 
       const notifTargetUserInfo = { id: userID, username };
       const notifTexts = await notifTextsForMessageInfo(
         allMessageInfos,
         threadInfo,
         notifTargetUserInfo,
         getENSNames,
       );
       if (!notifTexts) {
         continue;
       }
 
       const dbID = dbIDs.shift();
       invariant(dbID, 'should have sufficient DB IDs');
       const byPlatform = getDevicesByPlatform(pushInfo[userID].devices);
       const firstMessageID = firstNewMessageInfo.id;
       invariant(firstMessageID, 'RawMessageInfo.id should be set on server');
       const notificationInfo = {
         source: 'new_message',
         dbID,
         userID,
         threadID,
         messageID: firstMessageID,
         collapseKey: notifInfo.collapseKey,
       };
 
       const iosVersionsToTokens = byPlatform.get('ios');
       if (iosVersionsToTokens) {
         for (const [versionKey, devices] of iosVersionsToTokens) {
           const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
 
           const platformDetails: PlatformDetails = {
             platform: 'ios',
             codeVersion,
             stateVersion,
           };
           const shimmedNewRawMessageInfos = shimUnsupportedRawMessageInfos(
             newRawMessageInfos,
             platformDetails,
           );
           const deliveryPromise = (async () => {
             const targetedNotifications = await prepareAPNsNotification(
               {
                 notifTexts,
                 newRawMessageInfos: shimmedNewRawMessageInfos,
                 threadID: threadInfo.id,
                 collapseKey: notifInfo.collapseKey,
                 badgeOnly,
                 unreadCount: unreadCounts[userID],
                 platformDetails,
               },
               devices,
             );
             return await sendAPNsNotification('ios', targetedNotifications, {
               ...notificationInfo,
               codeVersion,
               stateVersion,
             });
           })();
           deliveryPromises.push(deliveryPromise);
         }
       }
       const androidVersionsToTokens = byPlatform.get('android');
       if (androidVersionsToTokens) {
         for (const [versionKey, devices] of androidVersionsToTokens) {
           const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
           const platformDetails = {
             platform: 'android',
             codeVersion,
             stateVersion,
           };
           const shimmedNewRawMessageInfos = shimUnsupportedRawMessageInfos(
             newRawMessageInfos,
             platformDetails,
           );
           const deliveryPromise = (async () => {
             const targetedNotifications = await prepareAndroidNotification(
               {
                 notifTexts,
                 newRawMessageInfos: shimmedNewRawMessageInfos,
                 threadID: threadInfo.id,
                 collapseKey: notifInfo.collapseKey,
                 badgeOnly,
                 unreadCount: unreadCounts[userID],
                 platformDetails,
                 dbID,
               },
               devices,
             );
             return await sendAndroidNotification(targetedNotifications, {
               ...notificationInfo,
               codeVersion,
               stateVersion,
             });
           })();
           deliveryPromises.push(deliveryPromise);
         }
       }
       const webVersionsToTokens = byPlatform.get('web');
       if (webVersionsToTokens) {
         for (const [versionKey, devices] of webVersionsToTokens) {
           const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
           const platformDetails = {
             platform: 'web',
             codeVersion,
             stateVersion,
           };
 
           const deliveryPromise = (async () => {
             const notification = await prepareWebNotification({
               notifTexts,
               threadID: threadInfo.id,
               unreadCount: unreadCounts[userID],
               platformDetails,
             });
             const deviceTokens = devices.map(({ deviceToken }) => deviceToken);
             return await sendWebNotification(notification, deviceTokens, {
               ...notificationInfo,
               codeVersion,
               stateVersion,
             });
           })();
           deliveryPromises.push(deliveryPromise);
         }
       }
       const macosVersionsToTokens = byPlatform.get('macos');
       if (macosVersionsToTokens) {
         for (const [versionKey, devices] of macosVersionsToTokens) {
           const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
           const platformDetails = {
             platform: 'macos',
             codeVersion,
             stateVersion,
           };
           const shimmedNewRawMessageInfos = shimUnsupportedRawMessageInfos(
             newRawMessageInfos,
             platformDetails,
           );
           const deliveryPromise = (async () => {
             const targetedNotifications = await prepareAPNsNotification(
               {
                 notifTexts,
                 newRawMessageInfos: shimmedNewRawMessageInfos,
                 threadID: threadInfo.id,
                 collapseKey: notifInfo.collapseKey,
                 badgeOnly,
                 unreadCount: unreadCounts[userID],
                 platformDetails,
               },
               devices,
             );
             return await sendAPNsNotification('macos', targetedNotifications, {
               ...notificationInfo,
               codeVersion,
               stateVersion,
             });
           })();
           deliveryPromises.push(deliveryPromise);
         }
       }
       const windowsVersionsToTokens = byPlatform.get('windows');
       if (windowsVersionsToTokens) {
         for (const [versionKey, devices] of windowsVersionsToTokens) {
           const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
           const platformDetails = {
             platform: 'windows',
             codeVersion,
             stateVersion,
           };
 
           const deliveryPromise = (async () => {
             const notification = await prepareWNSNotification({
               notifTexts,
               threadID: threadInfo.id,
               unreadCount: unreadCounts[userID],
               platformDetails,
             });
             const deviceTokens = devices.map(({ deviceToken }) => deviceToken);
             return await sendWNSNotification(notification, deviceTokens, {
               ...notificationInfo,
               codeVersion,
               stateVersion,
             });
           })();
           deliveryPromises.push(deliveryPromise);
         }
       }
 
       for (const newMessageInfo of remainingNewMessageInfos) {
         const newDBID = dbIDs.shift();
         invariant(newDBID, 'should have sufficient DB IDs');
         const messageID = newMessageInfo.id;
         invariant(messageID, 'RawMessageInfo.id should be set on server');
         notifications.set(newDBID, {
           dbID: newDBID,
           userID,
           threadID: newMessageInfo.threadID,
           messageID,
           collapseKey: notifInfo.collapseKey,
           deliveries: [{ collapsedInto: dbID }],
         });
       }
     }
   }
 
   const cleanUpPromises = [];
   if (dbIDs.length > 0) {
     const query = SQL`DELETE FROM ids WHERE id IN (${dbIDs})`;
     cleanUpPromises.push(dbQuery(query));
   }
   const [deliveryResults] = await Promise.all([
     Promise.all(deliveryPromises),
     Promise.all(cleanUpPromises),
   ]);
 
   await saveNotifResults(deliveryResults, notifications, true);
 }
 
 async function sendRescindNotifs(rescindInfo: PushInfo) {
   if (Object.keys(rescindInfo).length === 0) {
     return;
   }
 
   const usersToCollapsableNotifInfo = await fetchCollapsableNotifs(rescindInfo);
 
   const promises = [];
   for (const userID in usersToCollapsableNotifInfo) {
     for (const notifInfo of usersToCollapsableNotifInfo[userID]) {
       for (const existingMessageInfo of notifInfo.existingMessageInfos) {
         const rescindCondition = SQL`
           n.user = ${userID} AND
           n.thread = ${existingMessageInfo.threadID} AND
           n.message = ${existingMessageInfo.id}
         `;
 
         promises.push(rescindPushNotifs(rescindCondition));
       }
     }
   }
 
   await Promise.all(promises);
 }
 
 // The results in deliveryResults will be combined with the rows
 // in rowsToSave and then written to the notifications table
 async function saveNotifResults(
   deliveryResults: $ReadOnlyArray<PushResult>,
   inputRowsToSave: Map<string, NotificationRow>,
   rescindable: boolean,
 ) {
   const rowsToSave = new Map(inputRowsToSave);
 
   const allInvalidTokens = [];
   for (const deliveryResult of deliveryResults) {
     const { info, delivery, invalidTokens } = deliveryResult;
     const { dbID, userID } = info;
     const curNotifRow = rowsToSave.get(dbID);
     if (curNotifRow) {
       curNotifRow.deliveries.push(delivery);
     } else {
       // Ternary expressions for Flow
       const threadID = info.threadID ? info.threadID : null;
       const messageID = info.messageID ? info.messageID : null;
       const collapseKey = info.collapseKey ? info.collapseKey : null;
       rowsToSave.set(dbID, {
         dbID,
         userID,
         threadID,
         messageID,
         collapseKey,
         deliveries: [delivery],
       });
     }
     if (invalidTokens) {
       allInvalidTokens.push({
         userID,
         tokens: invalidTokens,
       });
     }
   }
 
   const notificationRows = [];
   for (const notification of rowsToSave.values()) {
     notificationRows.push([
       notification.dbID,
       notification.userID,
       notification.threadID,
       notification.messageID,
       notification.collapseKey,
       JSON.stringify(notification.deliveries),
       Number(!rescindable),
     ]);
   }
 
   const dbPromises = [];
   if (allInvalidTokens.length > 0) {
     dbPromises.push(removeInvalidTokens(allInvalidTokens));
   }
   if (notificationRows.length > 0) {
     const query = SQL`
       INSERT INTO notifications
         (id, user, thread, message, collapse_key, delivery, rescinded)
       VALUES ${notificationRows}
     `;
     dbPromises.push(dbQuery(query));
   }
   if (dbPromises.length > 0) {
     await Promise.all(dbPromises);
   }
 }
 
 async function fetchInfos(pushInfo: PushInfo) {
   const usersToCollapsableNotifInfo = await fetchCollapsableNotifs(pushInfo);
 
   const threadIDs = new Set();
   const threadWithChangedNamesToMessages = new Map();
   const addThreadIDsFromMessageInfos = (rawMessageInfo: RawMessageInfo) => {
     const threadID = rawMessageInfo.threadID;
     threadIDs.add(threadID);
     const messageSpec = messageSpecs[rawMessageInfo.type];
     if (messageSpec.threadIDs) {
       for (const id of messageSpec.threadIDs(rawMessageInfo)) {
         threadIDs.add(id);
       }
     }
     if (
       rawMessageInfo.type === messageTypes.CHANGE_SETTINGS &&
       rawMessageInfo.field === 'name'
     ) {
       const messages = threadWithChangedNamesToMessages.get(threadID);
       if (messages) {
         messages.push(rawMessageInfo.id);
       } else {
         threadWithChangedNamesToMessages.set(threadID, [rawMessageInfo.id]);
       }
     }
   };
   for (const userID in usersToCollapsableNotifInfo) {
     for (const notifInfo of usersToCollapsableNotifInfo[userID]) {
       for (const rawMessageInfo of notifInfo.existingMessageInfos) {
         addThreadIDsFromMessageInfos(rawMessageInfo);
       }
       for (const rawMessageInfo of notifInfo.newMessageInfos) {
         addThreadIDsFromMessageInfos(rawMessageInfo);
       }
     }
   }
 
   const promises = {};
   // These threadInfos won't have currentUser set
   promises.threadResult = fetchServerThreadInfos({ threadIDs });
   if (threadWithChangedNamesToMessages.size > 0) {
     const typesThatAffectName = [
       messageTypes.CHANGE_SETTINGS,
       messageTypes.CREATE_THREAD,
     ];
     const oldNameQuery = SQL`
       SELECT IF(
         JSON_TYPE(JSON_EXTRACT(m.content, "$.name")) = 'NULL',
         "",
         JSON_UNQUOTE(JSON_EXTRACT(m.content, "$.name"))
       ) AS name, m.thread
       FROM (
         SELECT MAX(id) AS id
         FROM messages
         WHERE type IN (${typesThatAffectName})
           AND JSON_EXTRACT(content, "$.name") IS NOT NULL
           AND`;
     const threadClauses = [];
     for (const [threadID, messages] of threadWithChangedNamesToMessages) {
       threadClauses.push(
         SQL`(thread = ${threadID} AND id NOT IN (${messages}))`,
       );
     }
     oldNameQuery.append(mergeOrConditions(threadClauses));
     oldNameQuery.append(SQL`
         GROUP BY thread
       ) x
       LEFT JOIN messages m ON m.id = x.id
     `);
     promises.oldNames = dbQuery(oldNameQuery);
   }
 
   const { threadResult, oldNames } = await promiseAll(promises);
   const serverThreadInfos = threadResult.threadInfos;
   if (oldNames) {
     const [result] = oldNames;
     for (const row of result) {
       const threadID = row.thread.toString();
       serverThreadInfos[threadID].name = row.name;
     }
   }
 
   const userInfos = await fetchNotifUserInfos(
     serverThreadInfos,
     usersToCollapsableNotifInfo,
   );
 
   return { usersToCollapsableNotifInfo, serverThreadInfos, userInfos };
 }
 
 async function fetchNotifUserInfos(
   serverThreadInfos: { +[threadID: string]: ServerThreadInfo },
   usersToCollapsableNotifInfo: { +[userID: string]: CollapsableNotifInfo[] },
 ) {
   const missingUserIDs = new Set();
 
   for (const threadID in serverThreadInfos) {
     const serverThreadInfo = serverThreadInfos[threadID];
     for (const member of serverThreadInfo.members) {
       missingUserIDs.add(member.id);
     }
   }
 
   const addUserIDsFromMessageInfos = (rawMessageInfo: RawMessageInfo) => {
     missingUserIDs.add(rawMessageInfo.creatorID);
     const userIDs =
       messageSpecs[rawMessageInfo.type].userIDs?.(rawMessageInfo) ?? [];
     for (const userID of userIDs) {
       missingUserIDs.add(userID);
     }
   };
 
   for (const userID in usersToCollapsableNotifInfo) {
     missingUserIDs.add(userID);
     for (const notifInfo of usersToCollapsableNotifInfo[userID]) {
       for (const rawMessageInfo of notifInfo.existingMessageInfos) {
         addUserIDsFromMessageInfos(rawMessageInfo);
       }
       for (const rawMessageInfo of notifInfo.newMessageInfos) {
         addUserIDsFromMessageInfos(rawMessageInfo);
       }
     }
   }
 
   return await fetchUserInfos([...missingUserIDs]);
 }
 
 async function createDBIDs(pushInfo: PushInfo): Promise<string[]> {
   let numIDsNeeded = 0;
   for (const userID in pushInfo) {
     numIDsNeeded += pushInfo[userID].messageInfos.length;
   }
   return await createIDs('notifications', numIDsNeeded);
 }
 
 type VersionKey = { codeVersion: number, stateVersion: number };
 const versionKeyRegex: RegExp = new RegExp(/^-?\d+\|-?\d+$/);
 function versionKeyToString(versionKey: VersionKey): string {
   return `${versionKey.codeVersion}|${versionKey.stateVersion}`;
 }
 
 function stringToVersionKey(versionKeyString: string): VersionKey {
   invariant(
     versionKeyRegex.test(versionKeyString),
     'should pass correct version key string',
   );
   const [codeVersion, stateVersion] = versionKeyString.split('|').map(Number);
   return { codeVersion, stateVersion };
 }
 
 function getDevicesByPlatform(
   devices: $ReadOnlyArray<Device>,
 ): Map<Platform, Map<string, Array<NotificationTargetDevice>>> {
   const byPlatform = new Map();
   for (const device of devices) {
     let innerMap = byPlatform.get(device.platform);
     if (!innerMap) {
       innerMap = new Map();
       byPlatform.set(device.platform, innerMap);
     }
     const codeVersion: number =
       device.codeVersion !== null &&
       device.codeVersion !== undefined &&
       device.platform !== 'windows' &&
       device.platform !== 'macos'
         ? device.codeVersion
         : -1;
     const stateVersion: number = device.stateVersion ?? -1;
 
     const versionKey = versionKeyToString({
       codeVersion,
       stateVersion,
     });
     let innerMostArray = innerMap.get(versionKey);
     if (!innerMostArray) {
       innerMostArray = [];
       innerMap.set(versionKey, innerMostArray);
     }
 
     innerMostArray.push({
       cookieID: device.cookieID,
       deviceToken: device.deviceToken,
     });
   }
   return byPlatform;
 }
 
 type APNsNotifInputData = {
   +notifTexts: ResolvedNotifTexts,
   +newRawMessageInfos: RawMessageInfo[],
   +threadID: string,
   +collapseKey: ?string,
   +badgeOnly: boolean,
   +unreadCount: number,
   +platformDetails: PlatformDetails,
 };
 const apnsNotifInputDataValidator = tShape<APNsNotifInputData>({
   notifTexts: resolvedNotifTextsValidator,
   newRawMessageInfos: t.list(rawMessageInfoValidator),
   threadID: tID,
   collapseKey: t.maybe(t.String),
   badgeOnly: t.Boolean,
   unreadCount: t.Number,
   platformDetails: tPlatformDetails,
 });
 async function prepareAPNsNotification(
   inputData: APNsNotifInputData,
   devices: $ReadOnlyArray<NotificationTargetDevice>,
 ): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
   const convertedData = validateOutput(
     inputData.platformDetails,
     apnsNotifInputDataValidator,
     inputData,
   );
   const {
     notifTexts,
     newRawMessageInfos,
     threadID,
     collapseKey,
     badgeOnly,
     unreadCount,
     platformDetails,
   } = convertedData;
 
   const isTextNotification = newRawMessageInfos.every(
     newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
   );
 
   const shouldBeEncrypted =
     platformDetails.platform === 'ios' &&
     !collapseKey &&
     isTextNotification &&
     platformDetails.codeVersion &&
     platformDetails.codeVersion > 222;
 
   const uniqueID = uuidv4();
   const notification = new apn.Notification();
   notification.topic = getAPNsNotificationTopic(platformDetails);
 
   const { merged, ...rest } = notifTexts;
   // We don't include alert's body on macos because we
   // handle displaying the notification ourselves and
   // we don't want macOS to display it automatically.
   if (!badgeOnly && platformDetails.platform !== 'macos') {
     notification.body = merged;
     notification.sound = 'default';
   }
   notification.payload = {
     ...notification.payload,
     ...rest,
   };
 
   notification.badge = unreadCount;
   notification.threadId = threadID;
   notification.id = uniqueID;
   notification.pushType = 'alert';
   notification.payload.id = uniqueID;
   notification.payload.threadID = threadID;
 
   if (platformDetails.codeVersion && platformDetails.codeVersion > 198) {
     notification.mutableContent = true;
   }
   if (collapseKey) {
     notification.collapseId = collapseKey;
   }
   const messageInfos = JSON.stringify(newRawMessageInfos);
   // We make a copy before checking notification's length, because calling
   // length compiles the notification and makes it immutable. Further
   // changes to its properties won't be reflected in the final plaintext
   // data that is sent.
   const copyWithMessageInfos = _cloneDeep(notification);
   copyWithMessageInfos.payload = {
     ...copyWithMessageInfos.payload,
     messageInfos,
   };
 
   const notificationSizeValidator = notif =>
     notif.length() <= apnMaxNotificationPayloadByteSize;
 
   if (!shouldBeEncrypted) {
     const notificationToSend = notificationSizeValidator(
       _cloneDeep(copyWithMessageInfos),
     )
       ? copyWithMessageInfos
       : notification;
     return devices.map(({ deviceToken }) => ({
       notification: notificationToSend,
       deviceToken,
     }));
   }
 
   const notifsWithMessageInfos = await prepareEncryptedIOSNotifications(
     devices,
     copyWithMessageInfos,
+    platformDetails.codeVersion,
     notificationSizeValidator,
   );
 
   const devicesWithExcessiveSize = notifsWithMessageInfos
     .filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
     .map(({ deviceToken, cookieID }) => ({ deviceToken, cookieID }));
 
   if (devicesWithExcessiveSize.length === 0) {
     return notifsWithMessageInfos.map(
       ({ notification: notif, deviceToken }) => ({
         notification: notif,
         deviceToken,
       }),
     );
   }
 
   const notifsWithoutMessageInfos = await prepareEncryptedIOSNotifications(
     devicesWithExcessiveSize,
     notification,
+    platformDetails.codeVersion,
   );
 
   const targetedNotifsWithMessageInfos = notifsWithMessageInfos
     .filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
     .map(({ notification: notif, deviceToken }) => ({
       notification: notif,
       deviceToken,
     }));
 
   const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
     ({ notification: notif, deviceToken }) => ({
       notification: notif,
       deviceToken,
     }),
   );
 
   return [
     ...targetedNotifsWithMessageInfos,
     ...targetedNotifsWithoutMessageInfos,
   ];
 }
 
 type AndroidNotifInputData = {
   ...APNsNotifInputData,
   +dbID: string,
 };
 const androidNotifInputDataValidator = tShape<AndroidNotifInputData>({
   ...apnsNotifInputDataValidator.meta.props,
   dbID: t.String,
 });
 async function prepareAndroidNotification(
   inputData: AndroidNotifInputData,
   devices: $ReadOnlyArray<NotificationTargetDevice>,
 ): Promise<$ReadOnlyArray<TargetedAndroidNotification>> {
   const convertedData = validateOutput(
     inputData.platformDetails,
     androidNotifInputDataValidator,
     inputData,
   );
   const {
     notifTexts,
     newRawMessageInfos,
     threadID,
     collapseKey,
     badgeOnly,
     unreadCount,
     platformDetails: { codeVersion },
     dbID,
   } = convertedData;
 
   const isTextNotification = newRawMessageInfos.every(
     newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
   );
 
   const shouldBeEncrypted =
     isTextNotification && !collapseKey && codeVersion && codeVersion > 228;
 
   const notifID = collapseKey ? collapseKey : dbID;
   const { merged, ...rest } = notifTexts;
   const notification = {
     data: {
       badge: unreadCount.toString(),
       ...rest,
       threadID,
     },
   };
 
   // The reason we only include `badgeOnly` for newer clients is because older
   // clients don't know how to parse it. The reason we only include `id` for
   // newer clients is that if the older clients see that field, they assume
   // the notif has a full payload, and then crash when trying to parse it.
   // By skipping `id` we allow old clients to still handle in-app notifs and
   // badge updating.
   if (!badgeOnly || (codeVersion && codeVersion >= 69)) {
     notification.data = {
       ...notification.data,
       id: notifID,
       badgeOnly: badgeOnly ? '1' : '0',
     };
   }
 
   const messageInfos = JSON.stringify(newRawMessageInfos);
   const copyWithMessageInfos = {
     ...notification,
     data: { ...notification.data, messageInfos },
   };
 
   if (!shouldBeEncrypted) {
     const notificationToSend =
       Buffer.byteLength(JSON.stringify(copyWithMessageInfos)) <=
       fcmMaxNotificationPayloadByteSize
         ? copyWithMessageInfos
         : notification;
 
     return devices.map(({ deviceToken }) => ({
       notification: notificationToSend,
       deviceToken,
     }));
   }
 
   const notificationsSizeValidator = notif => {
     const serializedNotif = JSON.stringify(notif);
     return (
       !serializedNotif ||
       Buffer.byteLength(serializedNotif) <= fcmMaxNotificationPayloadByteSize
     );
   };
 
   const notifsWithMessageInfos = await prepareEncryptedAndroidNotifications(
     devices,
     copyWithMessageInfos,
     notificationsSizeValidator,
   );
 
   const devicesWithExcessiveSize = notifsWithMessageInfos
     .filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
     .map(({ cookieID, deviceToken }) => ({ cookieID, deviceToken }));
 
   if (devicesWithExcessiveSize.length === 0) {
     return notifsWithMessageInfos.map(
       ({ notification: notif, deviceToken }) => ({
         notification: notif,
         deviceToken,
       }),
     );
   }
 
   const notifsWithoutMessageInfos = await prepareEncryptedAndroidNotifications(
     devicesWithExcessiveSize,
     notification,
   );
 
   const targetedNotifsWithMessageInfos = notifsWithMessageInfos
     .filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
     .map(({ notification: notif, deviceToken }) => ({
       notification: notif,
       deviceToken,
     }));
 
   const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
     ({ notification: notif, deviceToken }) => ({
       notification: notif,
       deviceToken,
     }),
   );
 
   return [
     ...targetedNotifsWithMessageInfos,
     ...targetedNotifsWithoutMessageInfos,
   ];
 }
 
 type WebNotifInputData = {
   +notifTexts: ResolvedNotifTexts,
   +threadID: string,
   +unreadCount: number,
   +platformDetails: PlatformDetails,
 };
 const webNotifInputDataValidator = tShape<WebNotifInputData>({
   notifTexts: resolvedNotifTextsValidator,
   threadID: tID,
   unreadCount: t.Number,
   platformDetails: tPlatformDetails,
 });
 async function prepareWebNotification(
   inputData: WebNotifInputData,
 ): Promise<WebNotification> {
   const convertedData = validateOutput(
     inputData.platformDetails,
     webNotifInputDataValidator,
     inputData,
   );
   const { notifTexts, threadID, unreadCount } = convertedData;
   const id = uuidv4();
   const { merged, ...rest } = notifTexts;
   const notification = {
     ...rest,
     unreadCount,
     id,
     threadID,
   };
   return notification;
 }
 
 type WNSNotifInputData = {
   +notifTexts: ResolvedNotifTexts,
   +threadID: string,
   +unreadCount: number,
   +platformDetails: PlatformDetails,
 };
 const wnsNotifInputDataValidator = tShape<WNSNotifInputData>({
   notifTexts: resolvedNotifTextsValidator,
   threadID: tID,
   unreadCount: t.Number,
   platformDetails: tPlatformDetails,
 });
 async function prepareWNSNotification(
   inputData: WNSNotifInputData,
 ): Promise<WNSNotification> {
   const convertedData = validateOutput(
     inputData.platformDetails,
     wnsNotifInputDataValidator,
     inputData,
   );
   const { notifTexts, threadID, unreadCount } = convertedData;
   const { merged, ...rest } = notifTexts;
   const notification = {
     ...rest,
     unreadCount,
     threadID,
   };
 
   if (
     Buffer.byteLength(JSON.stringify(notification)) >
     wnsMaxNotificationPayloadByteSize
   ) {
     console.warn('WNS notification exceeds size limit');
   }
   return notification;
 }
 
 type NotificationInfo =
   | {
       +source: 'new_message',
       +dbID: string,
       +userID: string,
       +threadID: string,
       +messageID: string,
       +collapseKey: ?string,
       +codeVersion: number,
       +stateVersion: number,
     }
   | {
       +source: 'mark_as_unread' | 'mark_as_read' | 'activity_update',
       +dbID: string,
       +userID: string,
       +codeVersion: number,
       +stateVersion: number,
     };
 
 type APNsDelivery = {
   source: $PropertyType<NotificationInfo, 'source'>,
   deviceType: 'ios' | 'macos',
   iosID: string,
   deviceTokens: $ReadOnlyArray<string>,
   codeVersion: number,
   stateVersion: number,
   errors?: $ReadOnlyArray<ResponseFailure>,
 };
 type APNsResult = {
   info: NotificationInfo,
   delivery: APNsDelivery,
   invalidTokens?: $ReadOnlyArray<string>,
 };
 async function sendAPNsNotification(
   platform: 'ios' | 'macos',
   targetedNotifications: $ReadOnlyArray<TargetedAPNsNotification>,
   notificationInfo: NotificationInfo,
 ): Promise<APNsResult> {
   const { source, codeVersion, stateVersion } = notificationInfo;
 
   const response = await apnPush({
     targetedNotifications,
     platformDetails: { platform, codeVersion },
   });
   invariant(
     new Set(targetedNotifications.map(({ notification }) => notification.id))
       .size === 1,
     'Encrypted versions of the same notification must share id value',
   );
   const iosID = targetedNotifications[0].notification.id;
   const deviceTokens = targetedNotifications.map(
     ({ deviceToken }) => deviceToken,
   );
   const delivery: APNsDelivery = {
     source,
     deviceType: platform,
     iosID,
     deviceTokens,
     codeVersion,
     stateVersion,
   };
   if (response.errors) {
     delivery.errors = response.errors;
   }
   const result: APNsResult = {
     info: notificationInfo,
     delivery,
   };
   if (response.invalidTokens) {
     result.invalidTokens = response.invalidTokens;
   }
   return result;
 }
 
 type PushResult = AndroidResult | APNsResult | WebResult | WNSResult;
 type PushDelivery = AndroidDelivery | APNsDelivery | WebDelivery | WNSDelivery;
 type AndroidDelivery = {
   source: $PropertyType<NotificationInfo, 'source'>,
   deviceType: 'android',
   androidIDs: $ReadOnlyArray<string>,
   deviceTokens: $ReadOnlyArray<string>,
   codeVersion: number,
   stateVersion: number,
   errors?: $ReadOnlyArray<Object>,
 };
 type AndroidResult = {
   info: NotificationInfo,
   delivery: AndroidDelivery,
   invalidTokens?: $ReadOnlyArray<string>,
 };
 async function sendAndroidNotification(
   targetedNotifications: $ReadOnlyArray<TargetedAndroidNotification>,
   notificationInfo: NotificationInfo,
 ): Promise<AndroidResult> {
   const collapseKey = notificationInfo.collapseKey
     ? notificationInfo.collapseKey
     : null; // for Flow...
   const { source, codeVersion, stateVersion } = notificationInfo;
   const response = await fcmPush({
     targetedNotifications,
     collapseKey,
     codeVersion,
   });
   const deviceTokens = targetedNotifications.map(
     ({ deviceToken }) => deviceToken,
   );
   const androidIDs = response.fcmIDs ? response.fcmIDs : [];
   const delivery: AndroidDelivery = {
     source,
     deviceType: 'android',
     androidIDs,
     deviceTokens,
     codeVersion,
     stateVersion,
   };
   if (response.errors) {
     delivery.errors = response.errors;
   }
   const result: AndroidResult = {
     info: notificationInfo,
     delivery,
   };
   if (response.invalidTokens) {
     result.invalidTokens = response.invalidTokens;
   }
   return result;
 }
 
 type WebDelivery = {
   +source: $PropertyType<NotificationInfo, 'source'>,
   +deviceType: 'web',
   +deviceTokens: $ReadOnlyArray<string>,
   +codeVersion?: number,
   +stateVersion: number,
   +errors?: $ReadOnlyArray<WebPushError>,
 };
 type WebResult = {
   +info: NotificationInfo,
   +delivery: WebDelivery,
   +invalidTokens?: $ReadOnlyArray<string>,
 };
 async function sendWebNotification(
   notification: WebNotification,
   deviceTokens: $ReadOnlyArray<string>,
   notificationInfo: NotificationInfo,
 ): Promise<WebResult> {
   const { source, codeVersion, stateVersion } = notificationInfo;
 
   const response = await webPush({
     notification,
     deviceTokens,
   });
 
   const delivery: WebDelivery = {
     source,
     deviceType: 'web',
     deviceTokens,
     codeVersion,
     errors: response.errors,
     stateVersion,
   };
   const result: WebResult = {
     info: notificationInfo,
     delivery,
     invalidTokens: response.invalidTokens,
   };
   return result;
 }
 
 type WNSDelivery = {
   +source: $PropertyType<NotificationInfo, 'source'>,
   +deviceType: 'windows',
   +wnsIDs: $ReadOnlyArray<string>,
   +deviceTokens: $ReadOnlyArray<string>,
   +codeVersion?: number,
   +stateVersion: number,
   +errors?: $ReadOnlyArray<WNSPushError>,
 };
 type WNSResult = {
   +info: NotificationInfo,
   +delivery: WNSDelivery,
   +invalidTokens?: $ReadOnlyArray<string>,
 };
 async function sendWNSNotification(
   notification: WNSNotification,
   deviceTokens: $ReadOnlyArray<string>,
   notificationInfo: NotificationInfo,
 ): Promise<WNSResult> {
   const { source, codeVersion, stateVersion } = notificationInfo;
 
   const response = await wnsPush({
     notification,
     deviceTokens,
   });
 
   const wnsIDs = response.wnsIDs ?? [];
   const delivery: WNSDelivery = {
     source,
     deviceType: 'windows',
     wnsIDs,
     deviceTokens,
     codeVersion,
     errors: response.errors,
     stateVersion,
   };
   const result: WNSResult = {
     info: notificationInfo,
     delivery,
     invalidTokens: response.invalidTokens,
   };
   return result;
 }
 
 type InvalidToken = {
   +userID: string,
   +tokens: $ReadOnlyArray<string>,
 };
 async function removeInvalidTokens(
   invalidTokens: $ReadOnlyArray<InvalidToken>,
 ): Promise<void> {
   const sqlTuples = invalidTokens.map(
     invalidTokenUser =>
       SQL`(
       user = ${invalidTokenUser.userID} AND
       device_token IN (${invalidTokenUser.tokens})
     )`,
   );
   const sqlCondition = mergeOrConditions(sqlTuples);
 
   const selectQuery = SQL`
     SELECT id, user, device_token
     FROM cookies
     WHERE
   `;
   selectQuery.append(sqlCondition);
   const [result] = await dbQuery(selectQuery);
 
   const userCookiePairsToInvalidDeviceTokens = new Map();
   for (const row of result) {
     const userCookiePair = `${row.user}|${row.id}`;
     const existing = userCookiePairsToInvalidDeviceTokens.get(userCookiePair);
     if (existing) {
       existing.add(row.device_token);
     } else {
       userCookiePairsToInvalidDeviceTokens.set(
         userCookiePair,
         new Set([row.device_token]),
       );
     }
   }
 
   const time = Date.now();
   const promises = [];
   for (const entry of userCookiePairsToInvalidDeviceTokens) {
     const [userCookiePair, deviceTokens] = entry;
     const [userID, cookieID] = userCookiePair.split('|');
     const updateDatas = [...deviceTokens].map(deviceToken => ({
       type: updateTypes.BAD_DEVICE_TOKEN,
       userID,
       time,
       deviceToken,
       targetCookie: cookieID,
     }));
     promises.push(createUpdates(updateDatas));
   }
 
   const updateQuery = SQL`
     UPDATE cookies
     SET device_token = NULL
     WHERE
   `;
   updateQuery.append(sqlCondition);
   promises.push(dbQuery(updateQuery));
 
   await Promise.all(promises);
 }
 
 async function updateBadgeCount(
   viewer: Viewer,
   source: 'mark_as_unread' | 'mark_as_read' | 'activity_update',
 ) {
   const { userID } = viewer;
 
   const deviceTokenQuery = SQL`
     SELECT platform, device_token, versions, id
     FROM cookies
     WHERE user = ${userID}
       AND device_token IS NOT NULL
   `;
   if (viewer.data.cookieID) {
     deviceTokenQuery.append(SQL`AND id != ${viewer.cookieID} `);
   }
   const [unreadCounts, [deviceTokenResult], [dbID]] = await Promise.all([
     getUnreadCounts([userID]),
     dbQuery(deviceTokenQuery),
     createIDs('notifications', 1),
   ]);
   const unreadCount = unreadCounts[userID];
   const devices = deviceTokenResult.map(row => {
     const versions = JSON.parse(row.versions);
     return {
       platform: row.platform,
       cookieID: row.id,
       deviceToken: row.device_token,
       codeVersion: versions?.codeVersion,
       stateVersion: versions?.stateVersion,
     };
   });
   const byPlatform = getDevicesByPlatform(devices);
 
   const deliveryPromises = [];
 
   const iosVersionsToTokens = byPlatform.get('ios');
   if (iosVersionsToTokens) {
     for (const [versionKey, deviceInfos] of iosVersionsToTokens) {
       const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
       const notification = new apn.Notification();
       notification.topic = getAPNsNotificationTopic({
         platform: 'ios',
         codeVersion,
         stateVersion,
       });
       notification.badge = unreadCount;
       notification.pushType = 'alert';
       const deliveryPromise = (async () => {
         let targetedNotifications;
         if (codeVersion > 222) {
           const notificationsArray = await prepareEncryptedIOSNotifications(
             deviceInfos,
             notification,
+            codeVersion,
           );
           targetedNotifications = notificationsArray.map(
             ({ notification: notif, deviceToken }) => ({
               notification: notif,
               deviceToken,
             }),
           );
         } else {
           targetedNotifications = deviceInfos.map(({ deviceToken }) => ({
             notification,
             deviceToken,
           }));
         }
         return await sendAPNsNotification('ios', targetedNotifications, {
           source,
           dbID,
           userID,
           codeVersion,
           stateVersion,
         });
       })();
 
       deliveryPromises.push(deliveryPromise);
     }
   }
 
   const androidVersionsToTokens = byPlatform.get('android');
   if (androidVersionsToTokens) {
     for (const [versionKey, deviceInfos] of androidVersionsToTokens) {
       const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
       const notificationData =
         codeVersion < 69
           ? { badge: unreadCount.toString() }
           : { badge: unreadCount.toString(), badgeOnly: '1' };
       const notification = { data: notificationData };
       const deliveryPromise = (async () => {
         let targetedNotifications;
         if (codeVersion > 222) {
           const notificationsArray = await prepareEncryptedAndroidNotifications(
             deviceInfos,
             notification,
           );
           targetedNotifications = notificationsArray.map(
             ({ notification: notif, deviceToken }) => ({
               notification: notif,
               deviceToken,
             }),
           );
         } else {
           targetedNotifications = deviceInfos.map(({ deviceToken }) => ({
             deviceToken,
             notification,
           }));
         }
         return await sendAndroidNotification(targetedNotifications, {
           source,
           dbID,
           userID,
           codeVersion,
           stateVersion,
         });
       })();
       deliveryPromises.push(deliveryPromise);
     }
   }
 
   const macosVersionsToTokens = byPlatform.get('macos');
   if (macosVersionsToTokens) {
     for (const [versionKey, deviceInfos] of macosVersionsToTokens) {
       const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
       const notification = new apn.Notification();
       notification.topic = getAPNsNotificationTopic({
         platform: 'macos',
         codeVersion,
         stateVersion,
       });
       notification.badge = unreadCount;
       notification.pushType = 'alert';
       const targetedNotifications = deviceInfos.map(({ deviceToken }) => ({
         deviceToken,
         notification,
       }));
       deliveryPromises.push(
         sendAPNsNotification('macos', targetedNotifications, {
           source,
           dbID,
           userID,
           codeVersion,
           stateVersion,
         }),
       );
     }
   }
 
   const deliveryResults = await Promise.all(deliveryPromises);
   await saveNotifResults(deliveryResults, new Map(), false);
 }
 
 export { sendPushNotifs, sendRescindNotifs, updateBadgeCount };
diff --git a/native/ios/NotificationService/NotificationService.mm b/native/ios/NotificationService/NotificationService.mm
index 036335bb6..be7a02838 100644
--- a/native/ios/NotificationService/NotificationService.mm
+++ b/native/ios/NotificationService/NotificationService.mm
@@ -1,248 +1,263 @@
 #import "NotificationService.h"
 #import "Logger.h"
 #import "NotificationsCryptoModule.h"
 #import "TemporaryMessageStorage.h"
 
 NSString *const backgroundNotificationTypeKey = @"backgroundNotifType";
 NSString *const messageInfosKey = @"messageInfos";
 NSString *const encryptedPayloadKey = @"encryptedPayload";
 NSString *const encryptionFailureKey = @"encryptionFailure";
 const std::string callingProcessName = "NSE";
 // The context for this constant can be found here:
 // https://linear.app/comm/issue/ENG-3074#comment-bd2f5e28
 int64_t const notificationRemovalDelay = (int64_t)(0.1 * NSEC_PER_SEC);
 CFStringRef newMessageInfosDarwinNotification =
     CFSTR("app.comm.darwin_new_message_infos");
 
 @interface NotificationService ()
 
 @property(nonatomic, strong) void (^contentHandler)
     (UNNotificationContent *contentToDeliver);
 @property(nonatomic, strong) UNMutableNotificationContent *bestAttemptContent;
 
 @end
 
 @implementation NotificationService
 
 - (void)didReceiveNotificationRequest:(UNNotificationRequest *)request
                    withContentHandler:
                        (void (^)(UNNotificationContent *_Nonnull))
                            contentHandler {
   self.contentHandler = contentHandler;
   self.bestAttemptContent = [request.content mutableCopy];
 
   if ([self shouldBeDecrypted:self.bestAttemptContent.userInfo]) {
     @try {
       [self decryptBestAttemptContent];
     } @catch (NSException *e) {
       comm::Logger::log(
           "NSE: Received exception: " + std::string([e.name UTF8String]) +
           " with reason: " + std::string([e.reason UTF8String]) +
           " during notification decryption");
       self.contentHandler([[UNNotificationContent alloc] init]);
       return;
     }
   } else if ([self shouldAlertUnencryptedNotification:self.bestAttemptContent
                                                           .userInfo]) {
     // In future this will be replaced by notification content
     // modification for DEV environment and staff members
     comm::Logger::log("NSE: Received erroneously unencrypted notitication.");
   }
 
   [self persistMessagePayload:self.bestAttemptContent.userInfo];
   // Message payload persistence is a higher priority task, so it has
   // to happen prior to potential notification center clearing.
   if ([self isRescind:self.bestAttemptContent.userInfo]) {
     [self removeNotificationWithIdentifier:self.bestAttemptContent
                                                .userInfo[@"notificationId"]];
     self.contentHandler([[UNNotificationContent alloc] init]);
     return;
   }
+
+  if ([self isBadgeOnly:self.bestAttemptContent.userInfo]) {
+    UNMutableNotificationContent *badgeOnlyContent =
+        [[UNMutableNotificationContent alloc] init];
+    badgeOnlyContent.badge = self.bestAttemptContent.badge;
+    self.contentHandler(badgeOnlyContent);
+    return;
+  }
+
   [self sendNewMessageInfosNotification];
   // TODO modify self.bestAttemptContent here
 
   self.contentHandler(self.bestAttemptContent);
 }
 
 - (void)serviceExtensionTimeWillExpire {
   // Called just before the extension will be terminated by the system.
   // Use this as an opportunity to deliver your "best attempt" at modified
   // content, otherwise the original push payload will be used.
   if ([self isRescind:self.bestAttemptContent.userInfo]) {
     // If we get to this place it means we were unable to
     // remove relevant notification from notification center in
     // in time given to NSE to process notification.
     // It is an extremely unlikely to happen.
     comm::Logger::log("NSE: Exceeded time limit to rescind a notification.");
     self.contentHandler([[UNNotificationContent alloc] init]);
     return;
   }
   if ([self shouldBeDecrypted:self.bestAttemptContent.userInfo] &&
       !self.bestAttemptContent.userInfo[@"succesfullyDecrypted"]) {
     // If we get to this place it means we were unable to
     // decrypt encrypted notification content in time
     // given to NSE to process notification.
     comm::Logger::log("NSE: Exceeded time limit to decrypt a notification.");
     self.contentHandler([[UNNotificationContent alloc] init]);
     return;
   }
   self.contentHandler(self.bestAttemptContent);
 }
 
 - (void)removeNotificationWithIdentifier:(NSString *)identifier {
   dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
 
   void (^delayedSemaphorePostCallback)() = ^() {
     dispatch_time_t timeToPostSemaphore =
         dispatch_time(DISPATCH_TIME_NOW, notificationRemovalDelay);
     dispatch_after(timeToPostSemaphore, dispatch_get_main_queue(), ^{
       dispatch_semaphore_signal(semaphore);
     });
   };
 
   [UNUserNotificationCenter.currentNotificationCenter
       getDeliveredNotificationsWithCompletionHandler:^(
           NSArray<UNNotification *> *_Nonnull notifications) {
         for (UNNotification *notif in notifications) {
           if ([identifier isEqual:notif.request.content.userInfo[@"id"]]) {
             [UNUserNotificationCenter.currentNotificationCenter
                 removeDeliveredNotificationsWithIdentifiers:@[
                   notif.request.identifier
                 ]];
           }
         }
         delayedSemaphorePostCallback();
       }];
 
   dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
 }
 
 - (void)persistMessagePayload:(NSDictionary *)payload {
   if (payload[messageInfosKey]) {
     TemporaryMessageStorage *temporaryStorage =
         [[TemporaryMessageStorage alloc] init];
     [temporaryStorage writeMessage:payload[messageInfosKey]];
     return;
   }
 
   if (![self isRescind:payload]) {
     return;
   }
 
   NSError *jsonError = nil;
   NSData *binarySerializedRescindPayload =
       [NSJSONSerialization dataWithJSONObject:payload
                                       options:0
                                         error:&jsonError];
   if (jsonError) {
     comm::Logger::log(
         "NSE: Failed to serialize rescind payload. Details: " +
         std::string([jsonError.localizedDescription UTF8String]));
     return;
   }
 
   NSString *serializedRescindPayload =
       [[NSString alloc] initWithData:binarySerializedRescindPayload
                             encoding:NSUTF8StringEncoding];
 
   TemporaryMessageStorage *temporaryRescindsStorage =
       [[TemporaryMessageStorage alloc] initForRescinds];
   [temporaryRescindsStorage writeMessage:serializedRescindPayload];
 }
 
 - (BOOL)isRescind:(NSDictionary *)payload {
   return payload[backgroundNotificationTypeKey] &&
       [payload[backgroundNotificationTypeKey] isEqualToString:@"CLEAR"];
 }
 
+- (BOOL)isBadgeOnly:(NSDictionary *)payload {
+  // TODO: refactor this check by introducing
+  // badgeOnly property in iOS notification payload
+  return !payload[@"threadID"];
+}
+
 - (void)sendNewMessageInfosNotification {
   CFNotificationCenterPostNotification(
       CFNotificationCenterGetDarwinNotifyCenter(),
       newMessageInfosDarwinNotification,
       (__bridge const void *)(self),
       nil,
       TRUE);
 }
 
 - (BOOL)shouldBeDecrypted:(NSDictionary *)payload {
   return payload[encryptedPayloadKey];
 }
 
 - (BOOL)shouldAlertUnencryptedNotification:(NSDictionary *)payload {
   return payload[encryptionFailureKey] &&
       [payload[encryptionFailureKey] isEqualToNumber:@(1)];
 }
 
 - (NSString *)singleDecrypt:(NSString *)data {
   std::string encryptedData = std::string([data UTF8String]);
   return [NSString
       stringWithUTF8String:
           (comm::NotificationsCryptoModule::decrypt(
                encryptedData,
                comm::NotificationsCryptoModule::olmEncryptedTypeMessage,
                callingProcessName))
               .c_str()];
 }
 
 - (void)decryptBestAttemptContent {
   NSString *decryptedSerializedPayload = [self
       singleDecrypt:self.bestAttemptContent.userInfo[encryptedPayloadKey]];
   NSDictionary *decryptedPayload = [NSJSONSerialization
       JSONObjectWithData:[decryptedSerializedPayload
                              dataUsingEncoding:NSUTF8StringEncoding]
                  options:0
                    error:nil];
 
   NSMutableDictionary *mutableUserInfo =
       [self.bestAttemptContent.userInfo mutableCopy];
 
   NSMutableDictionary *mutableAps = nil;
   if (mutableUserInfo[@"aps"]) {
     mutableAps = [mutableUserInfo[@"aps"] mutableCopy];
   }
 
   NSString *body = decryptedPayload[@"merged"];
   if (body) {
     self.bestAttemptContent.body = body;
     if (mutableAps && mutableAps[@"alert"]) {
       mutableAps[@"alert"] = body;
     }
   }
 
   NSString *threadID = decryptedPayload[@"threadID"];
   if (threadID) {
     self.bestAttemptContent.threadIdentifier = threadID;
     mutableUserInfo[@"threadID"] = threadID;
     if (mutableAps) {
       mutableAps[@"thread-id"] = threadID;
     }
   }
 
   NSString *badgeStr = decryptedPayload[@"badge"];
   if (badgeStr) {
     NSNumber *badge = @([badgeStr intValue]);
     self.bestAttemptContent.badge = badge;
     if (mutableAps) {
       mutableAps[@"badge"] = badge;
     }
   }
 
   // The rest have been already decrypted and handled.
   static NSArray<NSString *> *handledKeys =
       @[ @"merged", @"badge", @"threadID" ];
 
   for (NSString *payloadKey in decryptedPayload) {
     if ([handledKeys containsObject:payloadKey]) {
       continue;
     }
     mutableUserInfo[payloadKey] = decryptedPayload[payloadKey];
   }
 
   if (mutableAps) {
     mutableUserInfo[@"aps"] = mutableAps;
   }
   [mutableUserInfo removeObjectForKey:encryptedPayloadKey];
   self.bestAttemptContent.userInfo = mutableUserInfo;
 }
 
 @end