Speed up build client performance (#354)

* allow storing and passing the api client

* speed up create by creating the api backend connection ahead of time

* sender address needs to be senderInboxId

* remove unused js file

* fix up the lint

README.md

@@ -69,7 +69,7 @@ conversation.send(text = "gm")
 
 // Listen for new messages in the conversation
 conversation.streamMessages().collect {
-    print("${it.senderAddress}: ${it.body}")
+    print("${it.senderInboxId}: ${it.body}")
 }
 ```
 
@@ -199,17 +199,17 @@ val nextPage = conversation.messages(limit = 25, beforeNs = messages[0].sentNs)
 
 You can listen for any new messages (incoming or outgoing) in a conversation by calling `conversation.streamMessages()`.
 
-A successfully received message (that makes it through the decoding and decryption without throwing) can be trusted to be authentic. Authentic means that it was sent by the owner of the `message.senderAddress` account and that it wasn't modified in transit. The `message.sent` timestamp can be trusted to have been set by the sender.
+A successfully received message (that makes it through the decoding and decryption without throwing) can be trusted to be authentic. Authentic means that it was sent by the owner of the `message.senderInboxId` account and that it wasn't modified in transit. The `message.sent` timestamp can be trusted to have been set by the sender.
 
 The flow returned by the `stream` methods is an asynchronous data stream that sequentially emits values and completes normally or with an exception.
 
 ```kotlin
 conversation.streamMessages().collect {
-    if (it.senderAddress == client.address) {
+    if (it.senderInboxId == client.address) {
         // This message was sent from me
     }
 
-    print("New message from ${it.senderAddress}: ${it.body}")
+    print("New message from ${it.senderInboxId}: ${it.body}")
 }
 ```
 

example/src/main/java/org/xmtp/android/example/conversation/ConversationViewHolder.kt

@@ -39,7 +39,7 @@ class ConversationViewHolder(
         } else {
             ""
         }
-        val isMe = item.mostRecentMessage?.senderAddress == ClientManager.client.address
+        val isMe = item.mostRecentMessage?.senderInboxId == ClientManager.client.address
         if (messageBody.isNotBlank()) {
             binding.messageBody.text = if (isMe) binding.root.resources.getString(
                 R.string.your_message_body,

example/src/main/java/org/xmtp/android/example/message/MessageViewHolder.kt

@@ -28,7 +28,7 @@ class MessageViewHolder(
     @SuppressLint("SetTextI18n")
     fun bind(item: ConversationDetailViewModel.MessageListItem.Message) {
         val isFromMe =
-            ClientManager.client.address.lowercase() == item.message.senderAddress.lowercase()
+            ClientManager.client.address.lowercase() == item.message.senderInboxId.lowercase()
         val params = binding.messageContainer.layoutParams as ConstraintLayout.LayoutParams
         if (isFromMe) {
             params.rightToRight = PARENT_ID

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

@@ -557,10 +557,31 @@ class ClientTest {
         val time3 = end3.time - start3.time
         Log.d("PERF", "Built a client with inboxId in ${time3 / 1000.0}s")
 
+        val start4 = Date()
+        val buildClient3 = runBlocking {
+            Client().build(
+                fakeWallet.address,
+                options = ClientOptions(
+                    ClientOptions.Api(XMTPEnvironment.DEV, true),
+                    appContext = context,
+                    dbEncryptionKey = key
+                ),
+                inboxId = client.inboxId,
+                apiClient = client.apiClient
+            )
+        }
+        val end4 = Date()
+        val time4 = end4.time - start4.time
+        Log.d("PERF", "Built a client with inboxId and apiClient in ${time4 / 1000.0}s")
+
         assert(time2 < time1)
         assert(time3 < time1)
         assert(time3 < time2)
+        assert(time4 < time1)
+        assert(time4 < time2)
+        assert(time4 < time3)
         assertEquals(client.inboxId, buildClient1.inboxId)
         assertEquals(client.inboxId, buildClient2.inboxId)
+        assertEquals(client.inboxId, buildClient3.inboxId)
     }
 }

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

@@ -1,6 +1,7 @@
 package org.xmtp.android.library
 
 import android.content.Context
+import com.google.protobuf.api
 import kotlinx.coroutines.runBlocking
 import org.xmtp.android.library.codecs.ContentCodec
 import org.xmtp.android.library.codecs.TextCodec
@@ -10,6 +11,7 @@ import uniffi.xmtpv3.FfiConversationType
 import uniffi.xmtpv3.FfiDeviceSyncKind
 import uniffi.xmtpv3.FfiSignatureRequest
 import uniffi.xmtpv3.FfiXmtpClient
+import uniffi.xmtpv3.XmtpApiClient
 import uniffi.xmtpv3.connectToBackend
 import uniffi.xmtpv3.createClient
 import uniffi.xmtpv3.generateInboxId
@@ -47,6 +49,7 @@ class Client() {
     lateinit var conversations: Conversations
     lateinit var environment: XMTPEnvironment
     lateinit var dbPath: String
+    lateinit var apiClient: XmtpApiClient
     val libXMTPVersion: String = getVersionInfo()
     private lateinit var ffiClient: FfiXmtpClient
 
@@ -59,6 +62,10 @@ class Client() {
             registry
         }
 
+        suspend fun connectToApiBackend(api: ClientOptions.Api): XmtpApiClient {
+            return connectToBackend(api.env.getUrl(), api.isSecure)
+        }
+
         suspend fun getOrCreateInboxId(environment: ClientOptions.Api, address: String): String {
             var inboxId = getInboxIdForAddress(
                 host = environment.env.getUrl(),
@@ -79,6 +86,7 @@ class Client() {
             accountAddresses: List<String>,
             appContext: Context,
             api: ClientOptions.Api,
+            apiClient: XmtpApiClient? = null
         ): Map<String, Boolean> {
             val accountAddress = "0x0000000000000000000000000000000000000000"
             val inboxId = getOrCreateInboxId(api, accountAddress)
@@ -89,7 +97,7 @@ class Client() {
             val dbPath = directoryFile.absolutePath + "/$alias.db3"
 
             val ffiClient = createClient(
-                api = connectToBackend(api.env.getUrl(), api.isSecure),
+                api = apiClient ?: connectToApiBackend(api),
                 db = dbPath,
                 encryptionKey = null,
                 accountAddress = accountAddress.lowercase(),
@@ -114,6 +122,7 @@ class Client() {
         installationId: String,
         inboxId: String,
         environment: XMTPEnvironment,
+        apiClient: XmtpApiClient,
     ) : this() {
         this.address = address.lowercase()
         this.preferences = PrivatePreferences(client = this, ffiClient = libXMTPClient)
@@ -124,23 +133,26 @@ class Client() {
         this.installationId = installationId
         this.inboxId = inboxId
         this.environment = environment
+        this.apiClient = apiClient
     }
 
     private suspend fun initializeV3Client(
         address: String,
         clientOptions: ClientOptions,
         signingKey: SigningKey? = null,
         inboxId: String? = null,
+        apiClient: XmtpApiClient? = null,
     ): Client {
         val accountAddress = address.lowercase()
         val recoveredInboxId = inboxId ?: getOrCreateInboxId(clientOptions.api, accountAddress)
 
-        val (ffiClient, dbPath) = createFfiClient(
+        val (ffiClient, dbPath, apiClient) = createFfiClient(
             accountAddress,
             recoveredInboxId,
             clientOptions,
             signingKey,
             clientOptions.appContext,
+            apiClient,
         )
 
         return Client(
@@ -149,17 +161,19 @@ class Client() {
             dbPath,
             ffiClient.installationId().toHex(),
             ffiClient.inboxId(),
-            clientOptions.api.env
+            clientOptions.api.env,
+            apiClient
         )
     }
 
     // Function to create a V3 client with a signing key
     suspend fun create(
         account: SigningKey,
         options: ClientOptions,
+        apiClient: XmtpApiClient? = null
     ): Client {
         return try {
-            initializeV3Client(account.address, options, account)
+            initializeV3Client(account.address, options, account, apiClient = apiClient)
         } catch (e: Exception) {
             throw XMTPException("Error creating V3 client: ${e.message}", e)
         }
@@ -170,9 +184,10 @@ class Client() {
         address: String,
         options: ClientOptions,
         inboxId: String? = null,
+        apiClient: XmtpApiClient? = null,
     ): Client {
         return try {
-            initializeV3Client(address, options, inboxId = inboxId)
+            initializeV3Client(address, options, inboxId = inboxId, apiClient = apiClient)
         } catch (e: Exception) {
             throw XMTPException("Error creating V3 client: ${e.message}", e)
         }
@@ -184,7 +199,8 @@ class Client() {
         options: ClientOptions,
         signingKey: SigningKey?,
         appContext: Context,
-    ): Pair<FfiXmtpClient, String> {
+        apiClient: XmtpApiClient? = null,
+    ): Triple<FfiXmtpClient, String, XmtpApiClient> {
         val alias = "xmtp-${options.api.env}-$inboxId"
 
         val mlsDbDirectory = options.dbDirectory
@@ -196,8 +212,10 @@ class Client() {
         directoryFile.mkdir()
         dbPath = directoryFile.absolutePath + "/$alias.db3"
 
+        val xmtpApiClient =
+            apiClient ?: connectToApiBackend(options.api)
         val ffiClient = createClient(
-            api = connectToBackend(options.api.env.getUrl(), options.api.isSecure),
+            api = xmtpApiClient,
             db = dbPath,
             encryptionKey = options.dbEncryptionKey,
             accountAddress = accountAddress.lowercase(),
@@ -217,7 +235,7 @@ class Client() {
                 ?: throw XMTPException("No signer passed but signer was required.")
             ffiClient.registerIdentity(signatureRequest)
         }
-        return Pair(ffiClient, dbPath)
+        return Triple(ffiClient, dbPath, xmtpApiClient)
     }
 
     suspend fun revokeAllOtherInstallations(signingKey: SigningKey) {

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

@@ -10,7 +10,7 @@ data class DecodedMessage(
     val client: Client,
     var topic: String,
     var encodedContent: Content.EncodedContent,
-    var senderAddress: String,
+    var senderInboxId: String,
     var sent: Date,
     var sentNs: Long,
     var deliveryStatus: MessageDeliveryStatus = MessageDeliveryStatus.PUBLISHED

library/src/main/java/org/xmtp/android/library/libxmtp/Message.kt

@@ -52,7 +52,7 @@ data class Message(val client: Client, private val libXMTPMessage: FfiMessage) {
                 client = client,
                 topic = Topic.groupMessage(convoId).description,
                 encodedContent = EncodedContent.parseFrom(libXMTPMessage.content),
-                senderAddress = senderInboxId,
+                senderInboxId = senderInboxId,
                 sent = sentAt,
                 sentNs = sentAtNs,
                 deliveryStatus = deliveryStatus