feat: Rust V2

example/src/main/java/org/xmtp/android/example/MainActivity.kt

@@ -8,6 +8,7 @@ import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
 import android.os.Bundle
+import android.util.Log
 import android.view.Menu
 import android.view.MenuItem
 import android.view.View
@@ -182,6 +183,7 @@ class MainActivity : AppCompatActivity(),
 
     private fun showError(message: String) {
         val error = message.ifBlank { resources.getString(R.string.error) }
+        Log.e("MainActivity", message)
         Toast.makeText(this, error, Toast.LENGTH_SHORT).show()
     }
 

library/build.gradle

@@ -85,15 +85,15 @@ dependencies {
     implementation 'io.grpc:grpc-kotlin-stub:1.4.1'
     implementation 'io.grpc:grpc-okhttp:1.62.2'
     implementation 'io.grpc:grpc-protobuf-lite:1.62.2'
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0'
     implementation 'org.web3j:crypto:5.0.0'
     implementation "net.java.dev.jna:jna:5.14.0@aar"
     api 'com.google.protobuf:protobuf-kotlin-lite:3.22.3'
     api 'org.xmtp:proto-kotlin:3.61.1'
 
     testImplementation 'junit:junit:4.13.2'
-    androidTestImplementation 'app.cash.turbine:turbine:0.12.1'
-    androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3'
+    androidTestImplementation 'app.cash.turbine:turbine:1.1.0'
+    androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.0'
     androidTestImplementation 'androidx.test.ext:junit:1.1.5'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
 }

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

@@ -234,8 +234,8 @@ class ClientTest {
     fun testCanMessage() {
         val fixtures = fixtures()
         val notOnNetwork = PrivateKeyBuilder()
-        val canMessage = fixtures.aliceClient.canMessage(fixtures.bobClient.address)
-        val cannotMessage = fixtures.aliceClient.canMessage(notOnNetwork.address)
+        val canMessage = runBlocking { fixtures.aliceClient.canMessage(fixtures.bobClient.address) }
+        val cannotMessage = runBlocking { fixtures.aliceClient.canMessage(notOnNetwork.address) }
         assert(canMessage)
         assert(!cannotMessage)
     }
@@ -248,8 +248,8 @@ class ClientTest {
         val aliceClient = Client().create(aliceWallet, opts)
         runBlocking { aliceClient.ensureUserContactPublished() }
 
-        val canMessage = Client.canMessage(aliceWallet.address, opts)
-        val cannotMessage = Client.canMessage(notOnNetwork.address, opts)
+        val canMessage = runBlocking { Client.canMessage(aliceWallet.address, opts) }
+        val cannotMessage = runBlocking { Client.canMessage(notOnNetwork.address, opts) }
 
         assert(canMessage)
         assert(!cannotMessage)

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

@@ -27,19 +27,6 @@ class ContactsTest {
         assertEquals(contactBundle?.walletAddress, fixtures.bob.walletAddress)
     }
 
-    @Test
-    fun testCachesContacts() {
-        val fixtures = fixtures()
-        runBlocking { fixtures.bobClient.ensureUserContactPublished() }
-        // Look up the first time
-        fixtures.aliceClient.contacts.find(fixtures.bob.walletAddress)
-        fixtures.fakeApiClient.assertNoQuery {
-            val contactBundle = fixtures.aliceClient.contacts.find(fixtures.bob.walletAddress)
-            assertEquals(contactBundle?.walletAddress, fixtures.bob.walletAddress)
-        }
-        assert(fixtures.aliceClient.contacts.has(fixtures.bob.walletAddress))
-    }
-
     @Test
     fun testAllowAddress() {
         val fixtures = fixtures()

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

@@ -1,9 +1,11 @@
 package org.xmtp.android.library
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import app.cash.turbine.test
 import com.google.protobuf.kotlin.toByteString
 import com.google.protobuf.kotlin.toByteStringUtf8
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
@@ -46,7 +48,6 @@ import java.util.Date
 
 @RunWith(AndroidJUnit4::class)
 class ConversationTest {
-    lateinit var fakeApiClient: FakeApiClient
     lateinit var aliceWallet: PrivateKeyBuilder
     lateinit var bobWallet: PrivateKeyBuilder
     lateinit var alice: PrivateKey
@@ -62,7 +63,6 @@ class ConversationTest {
         alice = fixtures.alice
         bobWallet = fixtures.bobAccount
         bob = fixtures.bob
-        fakeApiClient = fixtures.fakeApiClient
         aliceClient = fixtures.aliceClient
         bobClient = fixtures.bobClient
     }
@@ -120,42 +120,11 @@ class ConversationTest {
             runBlocking { aliceClient.conversations.newConversation(bob.walletAddress) }
         assertEquals(conversation.peerAddress, bob.walletAddress)
         assertEquals(conversation.createdAt, someTimeAgo)
-        val existingMessages = fakeApiClient.published.size
         conversation = runBlocking { bobClient.conversations.newConversation(alice.walletAddress) }
-
-        assertEquals(
-            "published more messages when we shouldn't have",
-            existingMessages,
-            fakeApiClient.published.size,
-        )
         assertEquals(conversation.peerAddress, alice.walletAddress)
         assertEquals(conversation.createdAt, someTimeAgo)
     }
 
-    @Test
-    fun testCanFindExistingV2Conversation() {
-        val existingConversation = runBlocking {
-            bobClient.conversations.newConversation(
-                alice.walletAddress,
-                context = InvitationV1ContextBuilder.buildFromConversation("http://example.com/2"),
-            )
-        }
-        var conversation: Conversation? = null
-        fakeApiClient.assertNoPublish {
-            runBlocking {
-                conversation = bobClient.conversations.newConversation(
-                    alice.walletAddress,
-                    context = InvitationV1ContextBuilder.buildFromConversation("http://example.com/2"),
-                )
-            }
-        }
-        assertEquals(
-            "made new conversation instead of using existing one",
-            conversation!!.topic,
-            existingConversation.topic,
-        )
-    }
-
     @Test
     fun testCanLoadV1Messages() {
         // Overwrite contact as legacy so we can get v1
@@ -405,15 +374,6 @@ class ConversationTest {
         }
     }
 
-    @Test
-    fun testCanUseCachedConversation() {
-        runBlocking { bobClient.conversations.newConversation(alice.walletAddress) }
-
-        fakeApiClient.assertNoQuery {
-            runBlocking { bobClient.conversations.newConversation(alice.walletAddress) }
-        }
-    }
-
     @Test
     @Ignore("Rust seems to be Flaky with V1")
     fun testCanPaginateV1Messages() {
@@ -493,9 +453,18 @@ class ConversationTest {
             (topic.equals(steveConversation.topic) || topic.equals(bobConversation.topic))
         }
         assertEquals(3, messages.size)
-        assertTrue("isSteveOrBobConversation message 0", isSteveOrBobConversation(messages[0].topic))
-        assertTrue("isSteveOrBobConversation message 1", isSteveOrBobConversation(messages[1].topic))
-        assertTrue("isSteveOrBobConversation message 2", isSteveOrBobConversation(messages[2].topic))
+        assertTrue(
+            "isSteveOrBobConversation message 0",
+            isSteveOrBobConversation(messages[0].topic)
+        )
+        assertTrue(
+            "isSteveOrBobConversation message 1",
+            isSteveOrBobConversation(messages[1].topic)
+        )
+        assertTrue(
+            "isSteveOrBobConversation message 2",
+            isSteveOrBobConversation(messages[2].topic)
+        )
     }
 
     @Test
@@ -587,33 +556,82 @@ class ConversationTest {
     }
 
     @Test
-    fun testCanStreamConversationsV2() = kotlinx.coroutines.test.runTest {
-        bobClient.conversations.stream().test {
-            val conversation = bobClient.conversations.newConversation(alice.walletAddress)
-            conversation.send(content = "hi")
-            assertEquals("hi", awaitItem().messages(limit = 1).first().body)
+    fun testCanStreamConversationsV2() {
+        val allMessages = mutableListOf<String>()
+
+        val job = CoroutineScope(Dispatchers.IO).launch {
+            try {
+                bobClient.conversations.stream()
+                    .collect { message ->
+                        allMessages.add(message.topic)
+                    }
+            } catch (e: Exception) {
+            }
         }
+        Thread.sleep(2500)
+
+        runBlocking {
+            bobClient.conversations.newConversation(alice.walletAddress)
+        }
+
+        Thread.sleep(1000)
+
+        assertEquals(1, allMessages.size)
+
+        job.cancel()
     }
 
     @Test
-    fun testStreamingMessagesFromV1Conversation() = kotlinx.coroutines.test.runTest {
+    fun testStreamingMessagesFromV1Conversation() {
         // Overwrite contact as legacy
         fixtures.publishLegacyContact(client = bobClient)
         fixtures.publishLegacyContact(client = aliceClient)
-        val conversation = aliceClient.conversations.newConversation(bob.walletAddress)
-        conversation.streamMessages().test {
-            conversation.send("hi alice")
-            assertEquals("hi alice", awaitItem().encodedContent.content.toStringUtf8())
+        val conversation =
+            runBlocking { aliceClient.conversations.newConversation(bob.walletAddress) }
+        val allMessages = mutableListOf<DecodedMessage>()
+
+        val job = CoroutineScope(Dispatchers.IO).launch {
+            try {
+                conversation.streamMessages().collect { message ->
+                    allMessages.add(message)
+                }
+            } catch (e: Exception) {
+            }
+        }
+        Thread.sleep(2500)
+
+        for (i in 0 until 5) {
+            runBlocking { conversation.send(text = "Message $i") }
+            Thread.sleep(1000)
         }
+
+        assertEquals(allMessages.size, 5)
+        job.cancel()
     }
 
     @Test
-    fun testStreamingMessagesFromV2Conversations() = kotlinx.coroutines.test.runTest {
-        val conversation = aliceClient.conversations.newConversation(bob.walletAddress)
-        conversation.streamMessages().test {
-            conversation.send("hi alice")
-            assertEquals("hi alice", awaitItem().encodedContent.content.toStringUtf8())
+    fun testStreamingMessagesFromV2Conversations() {
+        val conversation =
+            runBlocking { aliceClient.conversations.newConversation(bob.walletAddress) }
+        val allMessages = mutableListOf<DecodedMessage>()
+
+        val job = CoroutineScope(Dispatchers.IO).launch {
+            try {
+                conversation.streamMessages().collect { message ->
+                    allMessages.add(message)
+                }
+            } catch (e: Exception) {
+            }
+        }
+        Thread.sleep(2500)
+
+        for (i in 0 until 5) {
+            runBlocking { conversation.send(text = "Message $i") }
+            Thread.sleep(1000)
         }
+
+        assertEquals(allMessages.size, 5)
+        job.cancel()
     }
 
     @Test
@@ -743,7 +761,6 @@ class ConversationTest {
         }.build()
 
         val client = Client().create(account = PrivateKeyBuilder(key))
-        assertEquals(client.apiClient.environment, XMTPEnvironment.DEV)
         runBlocking {
             val conversations = client.conversations.list()
             assertEquals(1, conversations.size)
@@ -788,11 +805,14 @@ class ConversationTest {
     fun testCanHaveConsentState() {
         val bobConversation =
             runBlocking { bobClient.conversations.newConversation(alice.walletAddress, null) }
+        Thread.sleep(1000)
         val isAllowed = bobConversation.consentState() == ConsentState.ALLOWED
-
         // Conversations you start should start as allowed
         assertTrue("Bob convo should be allowed", isAllowed)
-        assertTrue("Bob contacts should be allowed", bobClient.contacts.isAllowed(alice.walletAddress))
+        assertTrue(
+            "Bob contacts should be allowed",
+            bobClient.contacts.isAllowed(alice.walletAddress)
+        )
 
         runBlocking {
             bobClient.contacts.deny(listOf(alice.walletAddress))
@@ -829,6 +849,7 @@ class ConversationTest {
     fun testCanHaveImplicitConsentOnMessageSend() {
         val bobConversation =
             runBlocking { bobClient.conversations.newConversation(alice.walletAddress, null) }
+        Thread.sleep(1000)
         val isAllowed = bobConversation.consentState() == ConsentState.ALLOWED
 
         // Conversations you start should start as allowed
@@ -860,12 +881,24 @@ class ConversationTest {
             bobClient.contacts.refreshConsentList()
             Thread.sleep(1000)
             assertEquals(bobClient.contacts.consentList.entries.size, 2)
-            assertTrue("Bob convo should be allowed", bobConversation.consentState() == ConsentState.ALLOWED)
-            assertTrue("Caro convo should be allowed", caroConversation.consentState() == ConsentState.ALLOWED)
+            assertTrue(
+                "Bob convo should be allowed",
+                bobConversation.consentState() == ConsentState.ALLOWED
+            )
+            assertTrue(
+                "Caro convo should be allowed",
+                caroConversation.consentState() == ConsentState.ALLOWED
+            )
             bobClient.contacts.deny(listOf(alice.walletAddress, fixtures.caro.walletAddress))
             assertEquals(bobClient.contacts.consentList.entries.size, 2)
-            assertTrue("Bob convo should be denied", bobConversation.consentState() == ConsentState.DENIED)
-            assertTrue("Caro convo should be denied", caroConversation.consentState() == ConsentState.DENIED)
+            assertTrue(
+                "Bob convo should be denied",
+                bobConversation.consentState() == ConsentState.DENIED
+            )
+            assertTrue(
+                "Caro convo should be denied",
+                caroConversation.consentState() == ConsentState.DENIED
+            )
         }
     }
 

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

@@ -36,7 +36,6 @@ import java.util.Date
 
 @RunWith(AndroidJUnit4::class)
 class ConversationsTest {
-    lateinit var fakeApiClient: FakeApiClient
     lateinit var alixWallet: PrivateKeyBuilder
     lateinit var boWallet: PrivateKeyBuilder
     lateinit var alix: PrivateKey
@@ -53,7 +52,6 @@ class ConversationsTest {
         alix = fixtures.alice
         boWallet = fixtures.bobAccount
         bo = fixtures.bob
-        fakeApiClient = fixtures.fakeApiClient
         alixClient = fixtures.aliceClient
         boClient = fixtures.bobClient
         caroClient = fixtures.caroClient
@@ -128,7 +126,7 @@ class ConversationsTest {
             runBlocking { boConversation.send(text = "Message $i") }
             sleep(1000)
         }
-        assertEquals(allMessages.size, 5)
+        assertEquals(5, allMessages.size)
 
         val caroConversation =
             runBlocking { caroClient.conversations.newConversation(alixClient.address) }
@@ -139,7 +137,7 @@ class ConversationsTest {
             sleep(1000)
         }
 
-        assertEquals(allMessages.size, 10)
+        assertEquals(10, allMessages.size)
 
         job.cancel()
 
@@ -158,7 +156,7 @@ class ConversationsTest {
             sleep(1000)
         }
 
-        assertEquals(allMessages.size, 15)
+        assertEquals(15, allMessages.size)
     }
 
     @Test