LibXMTP Client Creation

example/src/main/java/org/xmtp/android/example/account/WalletConnectV2Account.kt

@@ -25,10 +25,10 @@ data class WalletConnectV2Account(
         )
 
     override suspend fun sign(data: ByteArray): SignatureOuterClass.Signature? {
-        return sign(String(data))
+        return signLegacy(String(data))
     }
 
-    override suspend fun sign(message: String): SignatureOuterClass.Signature? {
+    override suspend fun signLegacy(message: String): SignatureOuterClass.Signature? {
         val (parentChain, chainId, account) = session.namespaces.getValue(chain).accounts[0].split(":")
         val requestParams = session.namespaces.getValue(chain).methods.find { method ->
             method == "personal_sign"

library/src/androidTest/java/org/xmtp/android/library/TestHelpers.kt

@@ -50,8 +50,8 @@ class FakeWallet : SigningKey {
         return signature
     }
 
-    override suspend fun sign(message: String): Signature {
-        val signature = privateKeyBuilder.sign(message)
+    override suspend fun signLegacy(message: String): Signature {
+        val signature = privateKeyBuilder.signLegacy(message)
         return signature
     }
 }

library/src/main/java/org/xmtp/android/library/Client.kt

@@ -34,6 +34,9 @@ import org.xmtp.android.library.messages.walletAddress
 import org.xmtp.proto.message.api.v1.MessageApiOuterClass
 import org.xmtp.proto.message.api.v1.MessageApiOuterClass.BatchQueryResponse
 import org.xmtp.proto.message.api.v1.MessageApiOuterClass.QueryRequest
+import uniffi.xmtp_dh.FfiXmtpClient
+import uniffi.xmtp_dh.createClient
+import uniffi.xmtp_dh.org.xmtp.android.library.libxmtp.XMTPLogger
 import java.nio.charset.StandardCharsets
 import java.text.SimpleDateFormat
 import java.time.Instant
@@ -63,6 +66,8 @@ class Client() {
     lateinit var apiClient: ApiClient
     lateinit var contacts: Contacts
     lateinit var conversations: Conversations
+    lateinit var logger: XMTPLogger
+    var libXMTPClient: FfiXmtpClient? = null
 
     companion object {
         private const val TAG = "Client"
@@ -137,12 +142,15 @@ class Client() {
         address: String,
         privateKeyBundleV1: PrivateKeyBundleV1,
         apiClient: ApiClient,
+        libXmtpClient: FfiXmtpClient? = null
     ) : this() {
-        this.address = address
+        this.address = libXMTPClient?.accountAddress() ?: address
         this.privateKeyBundleV1 = privateKeyBundleV1
         this.apiClient = apiClient
         this.contacts = Contacts(client = this)
-        this.conversations = Conversations(client = this)
+        this.conversations = Conversations(client = this, libXMTPConversations = libXmtpClient?.conversations())
+        this.logger = XMTPLogger()
+        this.libXMTPClient = libXmtpClient
     }
 
     fun buildFrom(bundle: PrivateKeyBundleV1, options: ClientOptions? = null): Client {
@@ -153,18 +161,38 @@ class Client() {
         return Client(address = address, privateKeyBundleV1 = bundle, apiClient = apiClient)
     }
 
-    fun create(account: SigningKey, options: ClientOptions? = null): Client {
+    fun create(
+        account: SigningKey,
+        options: ClientOptions? = null,
+    ): Client {
         val clientOptions = options ?: ClientOptions()
         val apiClient =
             GRPCApiClient(environment = clientOptions.api.env, secure = clientOptions.api.isSecure)
-        return create(account = account, apiClient = apiClient, options = options)
+        return create(
+            account = account,
+            apiClient = apiClient,
+            options = options,
+        )
     }
 
-    fun create(account: SigningKey, apiClient: ApiClient, options: ClientOptions? = null): Client {
+    fun create(
+        account: SigningKey,
+        apiClient: ApiClient,
+        options: ClientOptions? = null,
+    ): Client {
         return runBlocking {
             try {
                 val privateKeyBundleV1 = loadOrCreateKeys(account, apiClient, options)
-                val client = Client(account.address, privateKeyBundleV1, apiClient)
+                val libXMTPClient: FfiXmtpClient =
+                    createClient(
+                        logger = logger,
+                        ffiInboxOwner = account,
+                        host = "https://dev.xmtp.network:5556",
+                        isSecure = true,
+                        db = null,
+                        encryptionKey = null
+                    )
+                val client = Client(account.address, privateKeyBundleV1, apiClient, libXMTPClient)
                 client.ensureUserContactPublished()
                 client
             } catch (e: java.lang.Exception) {

library/src/main/java/org/xmtp/android/library/Conversation.kt

@@ -24,14 +24,17 @@ sealed class Conversation {
     data class V1(val conversationV1: ConversationV1) : Conversation()
     data class V2(val conversationV2: ConversationV2) : Conversation()
 
-    enum class Version { V1, V2 }
+    data class Group(val group: org.xmtp.android.library.Group) : Conversation()
+
+    enum class Version { V1, V2, GROUP }
 
     // This indicates whether this a v1 or v2 conversation.
     val version: Version
         get() {
             return when (this) {
                 is V1 -> Version.V1
                 is V2 -> Version.V2
+                is Group -> Version.GROUP
             }
         }
 
@@ -41,6 +44,7 @@ sealed class Conversation {
             return when (this) {
                 is V1 -> conversationV1.sentAt
                 is V2 -> conversationV2.createdAt
+                is Group -> TODO()
             }
         }
 
@@ -50,6 +54,7 @@ sealed class Conversation {
             return when (this) {
                 is V1 -> conversationV1.peerAddress
                 is V2 -> conversationV2.peerAddress
+                is Group -> TODO()
             }
         }
 
@@ -60,6 +65,7 @@ sealed class Conversation {
             return when (this) {
                 is V1 -> null
                 is V2 -> conversationV2.context.conversationId
+                is Group -> null
             }
         }
 
@@ -68,13 +74,15 @@ sealed class Conversation {
             return when (this) {
                 is V1 -> null
                 is V2 -> conversationV2.keyMaterial
+                is Group -> null
             }
         }
 
     fun consentState(): ConsentState {
         val client: Client = when (this) {
             is V1 -> conversationV1.client
             is V2 -> conversationV2.client
+            is Group -> group.client
         }
         return client.contacts.consentList.state(address = peerAddress)
     }
@@ -99,13 +107,15 @@ sealed class Conversation {
                             .setKeyMaterial(conversationV2.keyMaterial.toByteString()),
                     ),
             ).build()
+            is Group -> TODO()
         }
     }
 
     fun decode(envelope: Envelope): DecodedMessage {
         return when (this) {
             is V1 -> conversationV1.decode(envelope)
             is V2 -> conversationV2.decodeEnvelope(envelope)
+            is Group -> TODO()
         }
     }
 
@@ -127,6 +137,8 @@ sealed class Conversation {
             is V2 -> {
                 conversationV2.prepareMessage(content = content, options = options)
             }
+
+            is Group -> TODO()
         }
     }
 
@@ -142,34 +154,40 @@ sealed class Conversation {
             is V2 -> {
                 conversationV2.prepareMessage(encodedContent = encodedContent, options = options)
             }
+
+            is Group -> TODO()
         }
     }
 
     fun send(prepared: PreparedMessage): String {
         return when (this) {
             is V1 -> conversationV1.send(prepared = prepared)
             is V2 -> conversationV2.send(prepared = prepared)
+            is Group -> TODO()
         }
     }
 
     fun <T> send(content: T, options: SendOptions? = null): String {
         return when (this) {
             is V1 -> conversationV1.send(content = content, options = options)
             is V2 -> conversationV2.send(content = content, options = options)
+            is Group -> TODO()
         }
     }
 
     fun send(text: String, sendOptions: SendOptions? = null, sentAt: Date? = null): String {
         return when (this) {
             is V1 -> conversationV1.send(text = text, sendOptions, sentAt)
             is V2 -> conversationV2.send(text = text, sendOptions, sentAt)
+            is Group -> group.send(text)
         }
     }
 
     fun send(encodedContent: EncodedContent, options: SendOptions? = null): String {
         return when (this) {
             is V1 -> conversationV1.send(encodedContent = encodedContent, options = options)
             is V2 -> conversationV2.send(encodedContent = encodedContent, options = options)
+            is Group -> TODO()
         }
     }
 
@@ -184,6 +202,7 @@ sealed class Conversation {
             return when (this) {
                 is V1 -> conversationV1.topic.description
                 is V2 -> conversationV2.topic
+                is Group -> group.id.toString()
             }
         }
 
@@ -221,6 +240,8 @@ sealed class Conversation {
                     after = after,
                     direction = direction,
                 )
+
+            is Group -> group.messages()
         }
     }
 
@@ -233,6 +254,7 @@ sealed class Conversation {
         return when (this) {
             is V1 -> conversationV1.decryptedMessages(limit, before, after, direction)
             is V2 -> conversationV2.decryptedMessages(limit, before, after, direction)
+            is Group -> TODO()
         }
     }
 
@@ -242,6 +264,7 @@ sealed class Conversation {
         return when (this) {
             is V1 -> conversationV1.decrypt(envelope)
             is V2 -> conversationV2.decrypt(envelope)
+            is Group -> TODO()
         }
     }
 
@@ -251,6 +274,7 @@ sealed class Conversation {
             return when (this) {
                 is V1 -> conversationV1.client
                 is V2 -> conversationV2.client
+                is Group -> group.client
             }
         }
 
@@ -262,20 +286,23 @@ sealed class Conversation {
         return when (this) {
             is V1 -> conversationV1.streamMessages()
             is V2 -> conversationV2.streamMessages()
+            is Group -> TODO()
         }
     }
 
     fun streamDecryptedMessages(): Flow<DecryptedMessage> {
         return when (this) {
             is V1 -> conversationV1.streamDecryptedMessages()
             is V2 -> conversationV2.streamDecryptedMessages()
+            is Group -> TODO()
         }
     }
 
     fun streamEphemeral(): Flow<Envelope> {
         return when (this) {
             is V1 -> return conversationV1.streamEphemeral()
             is V2 -> return conversationV2.streamEphemeral()
+            is Group -> TODO()
         }
     }
 }

library/src/main/java/org/xmtp/android/library/Conversations.kt

@@ -32,11 +32,13 @@ import org.xmtp.proto.keystore.api.v1.Keystore.TopicMap.TopicData
 import org.xmtp.proto.message.contents.Contact
 import org.xmtp.proto.message.contents.Invitation
 import org.xmtp.android.library.messages.DecryptedMessage
+import uniffi.xmtp_dh.FfiConversations
 import java.util.Date
 
 data class Conversations(
     var client: Client,
     var conversationsByTopic: MutableMap<String, Conversation> = mutableMapOf(),
+    val libXMTPConversations: FfiConversations? = null,
 ) {
 
     companion object {
@@ -81,6 +83,17 @@ data class Conversations(
         )
     }
 
+    suspend fun newGroup(accountAddress: String): Group {
+        val group = libXMTPConversations?.createGroup(accountAddress)
+            ?: throw XMTPException("Client does not support Groups")
+        return Group(client, group)
+    }
+
+    suspend fun listGroups(): List<Group> {
+        return libXMTPConversations?.list()?.map { Group(client, it) }
+            ?: throw XMTPException("Client does not support Groups")
+    }
+
     /**
      * This creates a new [Conversation] using a specified address
      * @param peerAddress The address of the client that you want to start a new conversation
@@ -174,7 +187,7 @@ data class Conversations(
      * Get the list of conversations that current user has
      * @return The list of [Conversation] that the current [Client] has.
      */
-    fun list(): List<Conversation> {
+    fun list(includeGroups: Boolean = false): List<Conversation> {
         val newConversations = mutableListOf<Conversation>()
         val mostRecent = conversationsByTopic.values.maxOfOrNull { it.createdAt }
         val pagination = Pagination(after = mostRecent)
@@ -203,7 +216,10 @@ data class Conversations(
             it.peerAddress != client.address && Topic.isValidTopic(it.topic)
         }.map { Pair(it.topic, it) }
 
-        // TODO(perf): use DB to persist + sort
+        if (includeGroups) {
+            val groups = runBlocking { listGroups() }
+            conversationsByTopic += groups.map { Pair(it.id.toString(), Conversation.Group(it)) }
+        }
         return conversationsByTopic.values.sortedByDescending { it.createdAt }
     }
 

library/src/main/java/org/xmtp/android/library/Group.kt

@@ -0,0 +1,32 @@
+package org.xmtp.android.library
+
+import kotlinx.coroutines.runBlocking
+import org.xmtp.android.library.libxmtp.Message
+import uniffi.xmtp_dh.FfiGroup
+import uniffi.xmtp_dh.FfiListMessagesOptions
+
+class Group(val client: Client, val libXMTPGroup: FfiGroup) {
+    val id: List<UByte>
+        get() = libXMTPGroup.id()
+
+    fun send(text: String): String {
+        runBlocking {
+            libXMTPGroup.send(
+                contentBytes = text.toByteArray(Charsets.UTF_8).toUByteArray().toList()
+            )
+        }
+        return id.toString()
+    }
+
+    suspend fun messages(): List<Message> {
+        return libXMTPGroup.findMessages(
+            opts = FfiListMessagesOptions(
+                sentBeforeNs = null,
+                sentAfterNs = null,
+                limit = null
+            )
+        ).map {
+            Message(client, it)
+        }
+    }
+}