Introduce group chat to xmtp-ios

Package.swift

@@ -20,14 +20,12 @@ let package = Package(
 	dependencies: [
 		// Dependencies declare other packages that this package depends on.
 		// .package(url: /* package url */, from: "1.0.0"),
-
 		.package(url: "https://github.com/GigaBitcoin/secp256k1.swift.git", exact: "0.10.0"),
 		.package(url: "https://github.com/argentlabs/web3.swift", from: "1.1.0"),
 		.package(url: "https://github.com/1024jp/GzipSwift", from: "5.2.0"),
 		.package(url: "https://github.com/bufbuild/connect-swift", exact: "0.3.0"),
 		.package(url: "https://github.com/apple/swift-docc-plugin.git", from: "1.0.0"),
 		.package(url: "https://github.com/xmtp/libxmtp-swift", revision: "503086d"),
-//		.package(path: "../libxmtp-swift")
 	],
 	targets: [
 		// Targets are the basic building blocks of a package. A target can define a module or a test suite.
@@ -39,7 +37,7 @@ let package = Package(
 				"web3.swift",
 				.product(name: "Gzip", package: "GzipSwift"),
 				.product(name: "Connect", package: "connect-swift"),
-				.product(name: "LibXMTP", package: "libxmtp-swift"),
+				.product(name: "LibXMTP", package: "libxmtp-swift")
 			]
 		),
 		.target(

Sources/XMTPiOS/Client.swift

@@ -107,7 +107,7 @@ public final class Client {
 	public static func create(account: SigningKey, options: ClientOptions? = nil) async throws -> Client {
 		let options = options ?? ClientOptions()
 		do {
-			let client = try await LibXMTP.createV2Client(host: options.api.env.url, isSecure: options.api.env != .local)
+			let client = try await LibXMTP.createV2Client(host: options.api.env.url, isSecure: options.api.env.isSecure)
 			let apiClient = try GRPCApiClient(
 				environment: options.api.env,
 				secure: options.api.isSecure,
@@ -126,12 +126,12 @@ public final class Client {
 		privateKeyBundleV1: PrivateKeyBundleV1,
 		signingKey: SigningKey?
 	) async throws -> FfiXmtpClient? {
-		if options?.mlsAlpha == true, options?.api.env == .local {
+		if options?.mlsAlpha == true, options?.api.env.supportsMLS == true {
 			let dbURL = URL.documentsDirectory.appendingPathComponent("xmtp-\(options?.api.env.rawValue ?? "")-\(address).db3")
 			let v3Client = try await LibXMTP.createClient(
 				logger: XMTPLogger(),
 				host: (options?.api.env ?? .local).url,
-				isSecure: (options?.api.env ?? .local) != .local,
+				isSecure: options?.api.env.isSecure == true,
 				db: dbURL.path,
 				encryptionKey: options?.mlsEncryptionKey,
 				accountAddress: address,
@@ -248,8 +248,7 @@ public final class Client {
 		let address = try v1Bundle.identityKey.publicKey.recoverWalletSignerPublicKey().walletAddress
 
 		let options = options ?? ClientOptions()
-
-		let client = try await LibXMTP.createV2Client(host: options.api.env.url, isSecure: options.api.env != .local)
+		let client = try await LibXMTP.createV2Client(host: options.api.env.url, isSecure: options.api.env.isSecure)
 		let apiClient = try GRPCApiClient(
 			environment: options.api.env,
 			secure: options.api.isSecure,
@@ -302,8 +301,7 @@ public final class Client {
 
 	public static func canMessage(_ peerAddress: String, options: ClientOptions? = nil) async throws -> Bool {
 		let options = options ?? ClientOptions()
-
-		let client = try await LibXMTP.createV2Client(host: options.api.env.url, isSecure: options.api.env != .local)
+		let client = try await LibXMTP.createV2Client(host: options.api.env.url, isSecure: options.api.env.isSecure)
 		let apiClient = try GRPCApiClient(
 			environment: options.api.env,
 			secure: options.api.isSecure,

Sources/XMTPiOS/CodecRegistry.swift

@@ -8,7 +8,9 @@
 import Foundation
 
 struct CodecRegistry {
-	var codecs: [String: any ContentCodec] = [TextCodec().id: TextCodec()]
+	var codecs: [String: any ContentCodec] = [
+		TextCodec().id: TextCodec(),
+	]
 
 	mutating func register(codec: any ContentCodec) {
 		codecs[codec.id] = codec

Sources/XMTPiOS/Codecs/GroupMembershipChanged.swift

@@ -0,0 +1,43 @@
+//
+//  GroupMembershipChanged.swift
+//  
+//
+//  Created by Pat Nakajima on 2/1/24.
+//
+
+import Foundation
+import LibXMTP
+
+public typealias GroupMembershipChanges = Xmtp_Mls_MessageContents_GroupMembershipChanges
+
+public let ContentTypeGroupMembershipChanged = ContentTypeID(authorityID: "xmtp.org", typeID: "group_membership_change", versionMajor: 1, versionMinor: 0)
+
+public struct GroupMembershipChangedCodec: ContentCodec {
+	public typealias T = GroupMembershipChanges
+
+	public init() {	}
+
+	public var contentType = ContentTypeGroupMembershipChanged
+
+	public func encode(content: GroupMembershipChanges, client _: Client) throws -> EncodedContent {
+		var encodedContent = EncodedContent()
+
+		encodedContent.type = ContentTypeGroupMembershipChanged
+		encodedContent.content = try content.serializedData()
+
+		return encodedContent
+	}
+
+	public func decode(content: EncodedContent, client _: Client) throws -> GroupMembershipChanges {
+		return try GroupMembershipChanges(serializedData: content.content)
+	}
+
+	public func fallback(content: GroupMembershipChanges) throws -> String? {
+		return nil
+	}
+
+	public func shouldPush(content: GroupMembershipChanges) throws -> Bool {
+		false
+	}
+}
+

Sources/XMTPiOS/Conversations.swift

@@ -1,4 +1,5 @@
 import Foundation
+import LibXMTP
 
 public enum ConversationError: Error, CustomStringConvertible {
 	case recipientNotOnNetwork, recipientIsSender, v1NotSupported(String)
@@ -15,15 +16,130 @@ public enum ConversationError: Error, CustomStringConvertible {
 	}
 }
 
+public enum GroupError: Error, CustomStringConvertible {
+	case alphaMLSNotEnabled, emptyCreation, memberCannotBeSelf, memberNotRegistered([String])
+
+	public var description: String {
+		switch self {
+		case .alphaMLSNotEnabled:
+			return "GroupError.alphaMLSNotEnabled"
+		case .emptyCreation:
+			return "GroupError.emptyCreation you cannot create an empty group"
+		case .memberCannotBeSelf:
+			return "GroupError.memberCannotBeSelf you cannot add yourself to a group"
+		case .memberNotRegistered(let array):
+			return "GroupError.memberNotRegistered members not registered: \(array.joined(separator: ", "))"
+		}
+	}
+}
+
+final class GroupStreamCallback: FfiConversationCallback {
+	let client: Client
+	let callback: (Group) -> Void
+
+	init(client: Client, callback: @escaping (Group) -> Void) {
+		self.client = client
+		self.callback = callback
+	}
+
+	func onConversation(conversation: FfiGroup) {
+		self.callback(conversation.fromFFI(client: client))
+	}
+}
+
 /// Handles listing and creating Conversations.
 public actor Conversations {
 	var client: Client
 	var conversationsByTopic: [String: Conversation] = [:]
+	let streamHolder = StreamHolder()
 
 	init(client: Client) {
 		self.client = client
 	}
 
+	public func sync() async throws {
+		guard let v3Client = client.v3Client else {
+			return
+		}
+
+		try await v3Client.conversations().sync()
+	}
+
+	public func groups(createdAfter: Date? = nil, createdBefore: Date? = nil, limit: Int? = nil) async throws -> [Group] {
+		guard let v3Client = client.v3Client else {
+			return []
+		}
+
+		var options = FfiListConversationsOptions(createdAfterNs: nil, createdBeforeNs: nil, limit: nil)
+
+		if let createdAfter {
+			options.createdAfterNs = Int64(createdAfter.millisecondsSinceEpoch)
+		}
+
+		if let createdBefore {
+			options.createdBeforeNs = Int64(createdBefore.millisecondsSinceEpoch)
+		}
+
+		if let limit {
+			options.limit = Int64(limit)
+		}
+
+		return try await v3Client.conversations().list(opts: options).map { $0.fromFFI(client: client) }
+	}
+
+	public func streamGroups() async throws -> AsyncThrowingStream<Group, Error> {
+		AsyncThrowingStream { continuation in
+			Task {
+				self.streamHolder.stream = try await self.client.v3Client?.conversations().stream(
+					callback: GroupStreamCallback(client: self.client) { group in
+						continuation.yield(group)
+					}
+				)
+			}
+		}
+	}
+
+	public func newGroup(with addresses: [String]) async throws -> Group {
+		guard let v3Client = client.v3Client else {
+			throw GroupError.alphaMLSNotEnabled
+		}
+
+		if addresses.isEmpty {
+			throw GroupError.emptyCreation
+		}
+
+		if addresses.first(where: { $0.lowercased() == client.address.lowercased() }) != nil {
+			throw GroupError.memberCannotBeSelf
+		}
+
+		let erroredAddresses = try await withThrowingTaskGroup(of: (String?).self) { group in
+			for address in addresses {
+				group.addTask {
+					if try await self.client.canMessageV3(address: address) {
+						return nil
+					} else {
+						return address
+					}
+				}
+			}
+
+			var results: [String] = []
+			for try await result in group {
+				if let result {
+					results.append(result)
+				}
+			}
+
+			return results
+		}
+
+		if !erroredAddresses.isEmpty {
+			throw GroupError.memberNotRegistered(erroredAddresses)
+		}
+
+		return try await v3Client.conversations().createGroup(accountAddresses: addresses).fromFFI(client: client)
+	}
+
 	/// Import a previously seen conversation.
 	/// See Conversation.toTopicData()
 	public func importTopicData(data: Xmtp_KeystoreApi_V1_TopicMap.TopicData) -> Conversation {

Sources/XMTPiOS/Extensions/Date.swift

@@ -11,4 +11,8 @@ extension Date {
 	var millisecondsSinceEpoch: Double {
 		timeIntervalSince1970 * 1000
 	}
+
+	init(millisecondsSinceEpoch: Int64) {
+		self.init(timeIntervalSince1970: TimeInterval(millisecondsSinceEpoch / 1_000_000_000))
+	}
 }

Sources/XMTPiOS/Extensions/Ffi.swift

@@ -192,3 +192,33 @@ extension FfiV2SubscribeRequest {
 		}
 	}
 }
+
+// MARK: Messages
+
+extension FfiMessage {
+	func fromFFI(client: Client) throws -> DecodedMessage {
+		let encodedContent = try EncodedContent(serializedData: content)
+
+		return DecodedMessage(
+			client: client,
+			topic: convoId.toHex,
+			encodedContent: encodedContent,
+			senderAddress: addrFrom,
+			sent: Date(timeIntervalSince1970: TimeInterval(sentAtNs / 1_000_000_000))
+		)
+	}
+}
+
+// MARK: Group
+
+extension FfiGroup {
+	func fromFFI(client: Client) -> Group {
+		Group(ffiGroup: self, client: client)
+	}
+}
+
+extension FfiGroupMember {
+	var fromFFI: Group.Member {
+		Group.Member(ffiGroupMember: self)
+	}
+}