feat: add sending and receiving of libsession encrypted msgs

still a wip though

ts/models/conversation.ts

@@ -21,7 +21,10 @@ import { from_hex } from 'libsodium-wrappers-sumo';
 import { SignalService } from '../protobuf';
 import { getMessageQueue } from '../session';
 import { getConversationController } from '../session/conversations';
-import { ClosedGroupVisibleMessage } from '../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
+import {
+  ClosedGroupV3VisibleMessage,
+  ClosedGroupVisibleMessage,
+} from '../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
 import { PubKey } from '../session/types';
 import { ToastUtils, UserUtils } from '../session/utils';
 import { BlockedNumberController } from '../util';
@@ -221,7 +224,9 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
   }
 
   public isClosedGroupV3(): boolean {
-    return Boolean(this.get('type') === ConversationTypeEnum.GROUPV3 && this.id.startsWith('03'));
+    return Boolean(
+      this.get('type') === ConversationTypeEnum.GROUPV3 && PubKey.isClosedGroupV2(this.id)
+    );
   }
 
   public isPrivate() {
@@ -1701,6 +1706,7 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
       // we are trying to send a message to someone. Make sure this convo is not hidden
       await this.unhideIfNeeded(true);
 
+      // TODO break down those functions  (sendMessage and retrySend into smaller functions and narrow the VisibleMessageParams to preview, etc. with checks of types)
       // an OpenGroupV2 message is just a visible message
       const chatMessageParams: VisibleMessageParams = {
         body,
@@ -1761,8 +1767,7 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
 
       if (this.isPrivate()) {
         if (this.isMe()) {
-          chatMessageParams.syncTarget = this.id;
-          const chatMessageMe = new VisibleMessage(chatMessageParams);
+          const chatMessageMe = new VisibleMessage({ ...chatMessageParams, syncTarget: this.id });
 
           await getMessageQueue().sendSyncMessage({
             namespace: SnodeNamespaces.Default,
@@ -1798,6 +1803,12 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
         return;
       }
 
+      if (this.isClosedGroupV3()) {
+        // we need the return await so that errors are caught in the catch {}
+        await this.sendMessageToGroupV3(chatMessageParams);
+        return;
+      }
+
       if (this.isClosedGroup()) {
         const chatMessageMediumGroup = new VisibleMessage(chatMessageParams);
         const closedGroupVisibleMessage = new ClosedGroupVisibleMessage({
@@ -1819,6 +1830,20 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
     }
   }
 
+  private async sendMessageToGroupV3(chatMessageParams: VisibleMessageParams) {
+    const visibleMessage = new VisibleMessage(chatMessageParams);
+    const groupVisibleMessage = new ClosedGroupV3VisibleMessage({
+      chatMessage: visibleMessage,
+      destination: this.id,
+      namespace: SnodeNamespaces.ClosedGroupMessages,
+    });
+
+    // we need the return await so that errors are caught in the catch {}
+    await getMessageQueue().sendToGroupV3({
+      message: groupVisibleMessage,
+    });
+  }
+
   private async sendBlindedMessageRequest(messageParams: VisibleMessageParams) {
     const ourSignKeyBytes = await UserUtils.getUserED25519KeyPairBytes();
     const groupUrl = this.getSogsOriginMessage();

ts/receiver/closedGroups.ts

@@ -87,7 +87,7 @@ export async function handleClosedGroupControlMessage(
     }`
   );
 
-  if (PubKey.isClosedGroupV3(envelope.source)) {
+  if (PubKey.isClosedGroupV2(envelope.source)) {
     window?.log?.warn(
       'Message ignored; closed group v3 updates cannot come from SignalService.DataMessage.ClosedGroupControlMessage '
     );
@@ -168,7 +168,7 @@ function sanityCheckNewGroup(
     return false;
   }
 
-  if (PubKey.isClosedGroupV3(hexGroupPublicKey)) {
+  if (PubKey.isClosedGroupV2(hexGroupPublicKey)) {
     window?.log?.warn('sanityCheckNewGroup: got a v3 new group as a ClosedGroupControlMessage. ');
     return false;
   }
@@ -520,7 +520,7 @@ async function performIfValid(
   const groupPublicKey = envelope.source;
   const sender = envelope.senderIdentity;
 
-  if (PubKey.isClosedGroupV3(groupPublicKey)) {
+  if (PubKey.isClosedGroupV2(groupPublicKey)) {
     window?.log?.warn(
       'Message ignored; closed group v3 updates cannot come from SignalService.DataMessage.ClosedGroupControlMessage '
     );

ts/receiver/contentMessage.ts

@@ -33,7 +33,11 @@ import { Storage } from '../util/storage';
 import { handleCallMessage } from './callMessage';
 import { getAllCachedECKeyPair, sentAtMoreRecentThanWrapper } from './closedGroups';
 import { ECKeyPair } from './keypairs';
-import { ContactsWrapperActions } from '../webworker/workers/browser/libsession_worker_interface';
+import {
+  ContactsWrapperActions,
+  MetaGroupWrapperActions,
+} from '../webworker/workers/browser/libsession_worker_interface';
+import { PreConditionFailed } from '../session/utils/errors';
 
 export async function handleSwarmContentMessage(envelope: EnvelopePlus, messageHash: string) {
   try {
@@ -54,6 +58,18 @@ export async function handleSwarmContentMessage(envelope: EnvelopePlus, messageH
   }
 }
 
+async function decryptForGroupV2(envelope: EnvelopePlus) {
+  window?.log?.info('received closed group message v2');
+  // try {
+  const groupPk = envelope.source;
+  if (!PubKey.isClosedGroupV2(groupPk)) {
+    throw new PreConditionFailed('decryptForGroupV2: not a 03 prefixed group');
+  }
+
+  return await MetaGroupWrapperActions.decryptMessage(groupPk, envelope.content);
+  // } catch (e) {}
+}
+
 async function decryptForClosedGroup(envelope: EnvelopePlus) {
   // case .closedGroupCiphertext: for ios
   window?.log?.info('received closed group message');
@@ -266,7 +282,11 @@ async function decrypt(envelope: EnvelopePlus): Promise<any> {
       plaintext = await decryptEnvelopeWithOurKey(envelope);
       break;
     case SignalService.Envelope.Type.CLOSED_GROUP_MESSAGE:
-      plaintext = await decryptForClosedGroup(envelope);
+      if (PubKey.isClosedGroupV2(envelope.source)) {
+        plaintext = await decryptForGroupV2(envelope);
+      } else {
+        plaintext = await decryptForClosedGroup(envelope);
+      }
       break;
     default:
       assertUnreachable(envelope.type, `Unknown message type:${envelope.type}`);

ts/receiver/dataMessage.ts

@@ -195,7 +195,7 @@ export async function handleSwarmDataMessage(
   );
 
   const isGroupMessage = !!envelope.senderIdentity;
-  const isGroupV3Message = isGroupMessage && PubKey.isClosedGroupV3(envelope.source);
+  const isGroupV3Message = isGroupMessage && PubKey.isClosedGroupV2(envelope.source);
   let typeOfConvo = ConversationTypeEnum.PRIVATE;
   if (isGroupV3Message) {
     typeOfConvo = ConversationTypeEnum.GROUPV3;

ts/session/apis/snode_api/batchRequest.ts

@@ -4,6 +4,12 @@ import { processOnionRequestErrorAtDestination, SnodeResponse } from './onions';
 import { snodeRpc } from './sessionRpc';
 import { NotEmptyArrayOfBatchResults, SnodeApiSubRequests } from './SnodeRequestTypes';
 
+function logSubRequests(requests: Array<SnodeApiSubRequests>) {
+  return requests.map(m =>
+    m.method === 'retrieve' || m.method === 'store' ? `${m.method}-${m.params.namespace}` : m.method
+  );
+}
+
 /**
  * This is the equivalent to the batch send on sogs. The target node runs each sub request and returns a list of all the sub status and bodies.
  * If the global status code is not 200, an exception is thrown.
@@ -23,7 +29,7 @@ export async function doSnodeBatchRequest(
 ): Promise<NotEmptyArrayOfBatchResults> {
   console.warn(
     `doSnodeBatchRequest "${method}":`,
-    JSON.stringify(subRequests.map(m => m.method))
+    JSON.stringify(logSubRequests(subRequests))
     // subRequests
   );
   const result = await snodeRpc({

ts/session/apis/snode_api/retrieveRequest.ts

@@ -93,7 +93,7 @@ async function retrieveRequestForGroup({
   namespace: SnodeNamespaces;
   retrieveParam: RetrieveParams;
 }) {
-  if (!PubKey.isClosedGroupV3(groupPk)) {
+  if (!PubKey.isClosedGroupV2(groupPk)) {
     throw new Error('retrieveRequestForGroup: not a 03 group');
   }
   if (!SnodeNamespace.isGroupNamespace(namespace)) {
@@ -147,7 +147,7 @@ async function buildRetrieveRequest(
         return retrieveRequestForLegacyGroup({ namespace, ourPubkey, pubkey, retrieveParam });
       }
 
-      if (PubKey.isClosedGroupV3(pubkey)) {
+      if (PubKey.isClosedGroupV2(pubkey)) {
         if (!SnodeNamespace.isGroupNamespace(namespace)) {
           // either config or messages namespaces for 03 groups
           throw new Error(`tried to poll from a non 03 group namespace ${namespace}`);

ts/session/apis/snode_api/snodeSignatures.ts

@@ -77,7 +77,7 @@ function isSigParamsForGroupAdmin(
   sigParams: SnodeSigParamsAdminGroup | SnodeSigParamsUs
 ): sigParams is SnodeSigParamsAdminGroup {
   const asGr = sigParams as SnodeSigParamsAdminGroup;
-  return PubKey.isClosedGroupV3(asGr.groupPk) && !!asGr.privKey;
+  return PubKey.isClosedGroupV2(asGr.groupPk) && !!asGr.privKey;
 }
 
 async function getSnodeShared(params: SnodeSigParamsAdminGroup | SnodeSigParamsUs) {

ts/session/apis/snode_api/swarmPolling.ts

@@ -191,7 +191,7 @@ export class SwarmPolling {
         window?.log?.debug(
           `Polling for ${loggingId}; timeout: ${convoPollingTimeout}; diff: ${diff} `
         );
-        if (PubKey.isClosedGroupV3(key)) {
+        if (PubKey.isClosedGroupV2(key)) {
           return this.pollOnceForKey([key, ConversationTypeEnum.GROUPV3]);
         }
         return this.pollOnceForKey([key, ConversationTypeEnum.GROUP]);
@@ -263,7 +263,7 @@ export class SwarmPolling {
     } else if (
       type === ConversationTypeEnum.GROUPV3 &&
       confMessages?.length &&
-      PubKey.isClosedGroupV3(pubkey)
+      PubKey.isClosedGroupV2(pubkey)
     ) {
       await SwarmPollingGroupConfig.handleGroupSharedConfigMessages(confMessages, pubkey);
     }

ts/session/conversations/ConversationController.ts

@@ -96,7 +96,7 @@ export class ConversationController {
       throw new TypeError(`'type' must be 'private' or 'group' or 'groupv3' but got: '${type}'`);
     }
 
-    if (type === ConversationTypeEnum.GROUPV3 && !PubKey.isClosedGroupV3(id)) {
+    if (type === ConversationTypeEnum.GROUPV3 && !PubKey.isClosedGroupV2(id)) {
       throw new Error(
         'required v3 closed group` ` but the pubkey does not match the 03 prefix for them'
       );
@@ -226,7 +226,7 @@ export class ConversationController {
     // if we were kicked or sent our left message, we have nothing to do more with that group.
     // Just delete everything related to it, not trying to add update message or send a left message.
     await this.removeGroupOrCommunityFromDBAndRedux(groupId);
-    if (PubKey.isClosedGroupV3(groupId)) {
+    if (PubKey.isClosedGroupV2(groupId)) {
       await remove03GroupFromWrappers(groupId);
     } else {
       await removeLegacyGroupFromWrappers(groupId);