Debug

SessionMessagingKit/Open Groups/V2/OpenGroupAPIV2.swift

@@ -171,7 +171,7 @@ public enum OpenGroupAPIV2 {
         guard let json = signedMessage.toJSON() else { return Promise(error: Error.parsingFailed) }
         let request = Request(verb: .post, room: room, server: server, endpoint: "messages", parameters: json)
         return send(request).map(on: DispatchQueue.global(qos: .userInitiated)) { json in
-            guard let message = OpenGroupMessageV2.fromJSON(json) else { throw Error.parsingFailed }
+            guard let rawMessage = json["message"] as? JSON, let message = OpenGroupMessageV2.fromJSON(rawMessage) else { throw Error.parsingFailed }
             return message
         }
     }
@@ -187,7 +187,7 @@ public enum OpenGroupAPIV2 {
             guard let rawMessages = json["messages"] as? [[String:Any]] else { throw Error.parsingFailed }
             let messages: [OpenGroupMessageV2] = rawMessages.compactMap { json in
                 // TODO: Signature validation
-                guard let message = OpenGroupMessageV2.fromJSON(json), message.serverID != nil else {
+                guard let message = OpenGroupMessageV2.fromJSON(json), message.serverID != nil, message.sender != nil else {
                     SNLog("Couldn't parse open group message from JSON: \(json).")
                     return nil
                 }

SessionMessagingKit/Open Groups/V2/OpenGroupManagerV2.swift

@@ -37,7 +37,10 @@ public final class OpenGroupManagerV2 : NSObject {
         let groupID = LKGroupUtilities.getEncodedOpenGroupIDAsData(openGroup.id)
         let model = TSGroupModel(title: openGroup.name, memberIds: [ getUserHexEncodedPublicKey() ], image: nil, groupId: groupID, groupType: .openGroup, adminIds: [])
         storage.write(with: { transaction in
-            let thread = TSGroupThread.getOrCreateThread(with: model, transaction: transaction as! YapDatabaseReadWriteTransaction)
+            let transaction = transaction as! YapDatabaseReadWriteTransaction
+            let thread = TSGroupThread.getOrCreateThread(with: model, transaction: transaction)
+            thread.shouldThreadBeVisible = true
+            thread.save(with: transaction)
             storage.setV2OpenGroup(openGroup, for: thread.uniqueId!, using: transaction)
         }, completion: {
             if let poller = OpenGroupManagerV2.shared.pollers[openGroup.id] {

SessionMessagingKit/Open Groups/V2/OpenGroupMessageV2.swift

@@ -1,6 +1,7 @@
 
 public struct OpenGroupMessageV2 {
     public let serverID: Int64?
+    public let sender: String?
     /// The serialized protobuf in base64 encoding.
     public let base64EncodedData: String
     /// When sending a message, the sender signs the serialized protobuf with their private key so that
@@ -14,12 +15,13 @@ public struct OpenGroupMessageV2 {
             SNLog("Failed to sign open group message.")
             return nil
         }
-        return OpenGroupMessageV2(serverID: serverID, base64EncodedData: base64EncodedData, base64EncodedSignature: signature.base64EncodedString())
+        return OpenGroupMessageV2(serverID: serverID, sender: sender, base64EncodedData: base64EncodedData, base64EncodedSignature: signature.base64EncodedString())
     }
 
     public func toJSON() -> JSON? {
         var result: JSON = [ "data" : base64EncodedData ]
         if let serverID = serverID { result["server_id"] = serverID }
+        if let sender = sender { result["public_key"] = sender }
         if let base64EncodedSignature = base64EncodedSignature { result["signature"] = base64EncodedSignature }
         return result
     }
@@ -27,7 +29,8 @@ public struct OpenGroupMessageV2 {
     public static func fromJSON(_ json: JSON) -> OpenGroupMessageV2? {
         guard let base64EncodedData = json["data"] as? String else { return nil }
         let serverID = json["server_id"] as? Int64
+        let sender = json["public_key"] as? String
         let base64EncodedSignature = json["signature"] as? String
-        return OpenGroupMessageV2(serverID: serverID, base64EncodedData: base64EncodedData, base64EncodedSignature: base64EncodedSignature)
+        return OpenGroupMessageV2(serverID: serverID, sender: sender, base64EncodedData: base64EncodedData, base64EncodedSignature: base64EncodedSignature)
     }
 }

SessionMessagingKit/Sending & Receiving/MessageSender.swift

@@ -335,7 +335,7 @@ public final class MessageSender : NSObject {
                 return promise
             }
             // Send the result
-            let openGroupMessage = OpenGroupMessageV2(serverID: nil, base64EncodedData: plaintext.base64EncodedString(), base64EncodedSignature: nil)
+            let openGroupMessage = OpenGroupMessageV2(serverID: nil, sender: nil, base64EncodedData: plaintext.base64EncodedString(), base64EncodedSignature: nil)
             OpenGroupAPIV2.send(openGroupMessage, to: room, on: server).done(on: DispatchQueue.global(qos: .userInitiated)) { openGroupMessage in
                 message.openGroupServerMessageID = given(openGroupMessage.serverID) { UInt64($0) }
                 storage.write(with: { transaction in

SessionMessagingKit/Sending & Receiving/Pollers/OpenGroupPollerV2.swift

@@ -75,14 +75,18 @@ public final class OpenGroupPollerV2 : NSObject {
                 guard let data = Data(base64Encoded: message.base64EncodedData) else {
                     return SNLog("Ignoring open group message with invalid encoding.")
                 }
-                let job = MessageReceiveJob(data: data, openGroupMessageServerID: UInt64(message.serverID!), openGroupID: self.openGroup.id, isBackgroundPoll: isBackgroundPoll)
+                let envelope = SNProtoEnvelope.builder(type: .sessionMessage, timestamp: 0)
+                envelope.setContent(data)
+                envelope.setSource(message.sender!) // Safe because messages with a nil sender are filtered out
+                let job = MessageReceiveJob(data: try! envelope.buildSerializedData(), openGroupMessageServerID: UInt64(message.serverID!), openGroupID: self.openGroup.id, isBackgroundPoll: isBackgroundPoll)
                 SNMessagingKitConfiguration.shared.storage.write { transaction in
                     SessionMessagingKit.JobQueue.shared.add(job, using: transaction)
                 }
             }
+            seal.fulfill(())
         }.catch(on: DispatchQueue.global(qos: .userInitiated)) { _ in
             seal.fulfill(()) // The promise is just used to keep track of when we're done
-        }.retainUntilComplete()
+        }
         return promise
     }