diff --git a/example/package.json b/example/package.json
index 95e33c0a7..f2c12fab1 100644
--- a/example/package.json
+++ b/example/package.json
@@ -32,6 +32,7 @@
     "react-native-encrypted-storage": "^4.0.3",
     "react-native-get-random-values": "^1.10.0",
     "react-native-mmkv": "^2.8.0",
+    "react-native-modal-selector": "^2.1.2",
     "react-native-quick-base64": "^2.0.8",
     "react-native-quick-crypto": "^0.6.1",
     "react-native-randombytes": "^3.6.1",
diff --git a/example/src/LaunchScreen.tsx b/example/src/LaunchScreen.tsx
index 326b3ee33..d0fbd4aee 100644
--- a/example/src/LaunchScreen.tsx
+++ b/example/src/LaunchScreen.tsx
@@ -2,6 +2,7 @@ import { NativeStackScreenProps } from '@react-navigation/native-stack'
 import { ConnectWallet, useSigner } from '@thirdweb-dev/react-native'
 import React, { useCallback, useEffect, useState } from 'react'
 import { Button, ScrollView, StyleSheet, Text, View } from 'react-native'
+import ModalSelector from 'react-native-modal-selector'
 import * as XMTP from 'xmtp-react-native-sdk'
 import { useXmtp } from 'xmtp-react-native-sdk'
 
@@ -12,9 +13,14 @@ import { useSavedKeys } from './hooks'
 const appVersion = 'XMTP_RN_EX/0.0.1'
 
 /// Prompt the user to run the tests, generate a wallet, or connect a wallet.
-export default function LaunchScreen({
-  navigation,
-}: NativeStackScreenProps<NavigationParamList, 'launch'>) {
+export default function LaunchScreen(
+  this: any,
+  { navigation }: NativeStackScreenProps<NavigationParamList, 'launch'>
+) {
+  const [selectedNetwork, setSelectedNetwork] = useState<
+    'dev' | 'local' | 'production'
+  >('dev')
+  const [enableGroups, setEnableGroups] = useState('true')
   const signer = useSigner()
   const [signerAddressDisplay, setSignerAddressDisplay] = useState<string>()
   const { setClient } = useXmtp()
@@ -48,6 +54,17 @@ export default function LaunchScreen({
     console.log('Pre Enable Identity Callback')
   }
 
+  const networkOptions = [
+    { key: 0, label: 'dev' },
+    { key: 1, label: 'local' },
+    // { key: 2, label: 'production' },
+  ]
+
+  const groupOptions = [
+    { key: 0, label: 'true' },
+    { key: 1, label: 'false' },
+  ]
+
   useEffect(() => {
     ;(async () => {
       if (signer) {
@@ -62,89 +79,76 @@ export default function LaunchScreen({
 
   return (
     <ScrollView>
-      <ConnectWallet theme="dark" />
-      <Text
-        style={{
-          fontSize: 16,
-          textAlign: 'right',
-          textTransform: 'uppercase',
-          color: '#333',
-          marginTop: 16,
-          paddingHorizontal: 16,
-          marginHorizontal: 16,
-        }}
-      >
-        Testing
-      </Text>
-      <View key="run-tests" style={{ margin: 16, marginTop: 16 }}>
+      <Text style={styles.title}>Automated Tests</Text>
+      <View key="run-tests" style={{ margin: 16 }}>
         <Button
-          title="Run Unit Tests"
-          onPress={() => navigation.navigate('test')}
+          title="Run All Unit Tests"
+          onPress={() => navigation.navigate('test', { onlyGroups: false })}
           accessibilityLabel="Unit-tests"
         />
       </View>
+      <View key="run-group-tests" style={{ margin: 16 }}>
+        <Button
+          title="Run Group Unit Tests"
+          onPress={() => navigation.navigate('test', { onlyGroups: true })}
+          accessibilityLabel="Unit-group-tests"
+        />
+      </View>
+      <View style={styles.divider} />
+      <Text style={styles.title}>Test Conversations</Text>
+      <View style={styles.row}>
+        <Text style={styles.label}>Select Network:</Text>
+        <ModalSelector
+          data={networkOptions}
+          selectStyle={styles.modalSelector}
+          initValueTextStyle={styles.modalSelectText}
+          selectTextStyle={styles.modalSelectText}
+          backdropPressToClose
+          initValue={selectedNetwork}
+          onChange={(option) =>
+            setSelectedNetwork(option.label as 'dev' | 'local' | 'production')
+          }
+        />
+      </View>
+      <View style={styles.row}>
+        <Text style={styles.label}>Enable Groups:</Text>
+        <ModalSelector
+          selectStyle={styles.modalSelector}
+          initValueTextStyle={styles.modalSelectText}
+          selectTextStyle={styles.modalSelectText}
+          backdropPressToClose
+          data={groupOptions}
+          initValue={enableGroups}
+          onChange={(option) => {
+            setEnableGroups(option.label)
+          }}
+        />
+      </View>
+      <View style={styles.row}>
+        <Text style={styles.label}>External Wallet:</Text>
+        <ConnectWallet theme="dark" />
+      </View>
       {signer && (
         <>
-          <Divider key="divider-connected" />
-          <Text
-            style={{
-              fontSize: 16,
-              textAlign: 'right',
-              textTransform: 'uppercase',
-              color: '#333',
-              paddingHorizontal: 16,
-              marginHorizontal: 16,
-            }}
-          >
-            Connected Wallet ({signerAddressDisplay})
-          </Text>
           <View key="connected-dev" style={{ margin: 16 }}>
             <Button
-              title="Use Connected Wallet (dev)"
-              color="green"
-              onPress={() => {
-                configureWallet(
-                  'dev',
-                  XMTP.Client.create(signer, {
-                    env: 'dev',
-                    appVersion,
-                    preCreateIdentityCallback,
-                    preEnableIdentityCallback,
-                  })
-                )
-              }}
-            />
-          </View>
-          <View key="connected-local" style={{ margin: 16 }}>
-            <Button
-              title="Use Connected Wallet (local)"
-              color="purple"
+              title={`Use Connected Wallet (${signerAddressDisplay} + )`}
+              color="orange"
               onPress={() => {
-                configureWallet(
-                  'local',
-                  XMTP.Client.create(signer, {
-                    env: 'local',
-                    appVersion,
-                    preCreateIdentityCallback,
-                    preEnableIdentityCallback,
-                  })
+                console.log(
+                  'Using network ' +
+                    selectedNetwork +
+                    ' and enableAlphaMLS ' +
+                    enableGroups
                 )
-              }}
-            />
-          </View>
-          <View key="connected-groups-local" style={{ margin: 16 }}>
-            <Button
-              title="Use Connected Wallet with Groups (local)"
-              color="purple"
-              onPress={() => {
                 configureWallet(
-                  'local',
+                  selectedNetwork,
                   XMTP.Client.create(signer, {
-                    env: 'local',
+                    env: selectedNetwork,
                     appVersion,
                     preCreateIdentityCallback,
                     preEnableIdentityCallback,
-                    enableAlphaMls: true,
+                    enableAlphaMls: enableGroups === 'true',
                   })
                 )
               }}
@@ -152,88 +156,26 @@ export default function LaunchScreen({
           </View>
         </>
       )}
-      <Divider key="divider-generated" />
-      <Text
-        style={{
-          fontSize: 16,
-          textAlign: 'right',
-          textTransform: 'uppercase',
-          color: '#333',
-          paddingHorizontal: 16,
-          marginHorizontal: 16,
-        }}
-      >
-        Random Wallet
-      </Text>
       <View key="generated-dev" style={{ margin: 16 }}>
         <Button
-          title="Use Generated Wallet (dev)"
+          title="Use Random Wallet"
           color="green"
           onPress={() => {
-            configureWallet(
-              'dev',
-              XMTP.Client.createRandom({
-                env: 'dev',
-                appVersion,
-                codecs: supportedCodecs,
-                preCreateIdentityCallback,
-                preEnableIdentityCallback,
-              })
+            console.log(
+              'Using network ' +
+                selectedNetwork +
+                ' and enableAlphaMLS ' +
+                enableGroups
             )
-          }}
-        />
-      </View>
-      <View key="generated-local" style={{ margin: 16 }}>
-        <Button
-          title="Use Generated Wallet (local)"
-          color="purple"
-          onPress={() => {
             configureWallet(
-              'local',
+              selectedNetwork,
               XMTP.Client.createRandom({
-                env: 'local',
-                appVersion,
-                codecs: supportedCodecs,
-                preCreateIdentityCallback,
-                preEnableIdentityCallback,
-              })
-            )
-          }}
-        />
-      </View>
-      <View key="generated-groups-local" style={{ margin: 16 }}>
-        <Button
-          title="Use Generated Wallet with Groups (local)"
-          color="purple"
-          onPress={() => {
-            configureWallet(
-              'local',
-              XMTP.Client.createRandom({
-                enableAlphaMls: true,
-                env: 'local',
-                appVersion,
-                codecs: supportedCodecs,
-                preCreateIdentityCallback,
-                preEnableIdentityCallback,
-              })
-            )
-          }}
-        />
-      </View>
-      <View key="generated-groups-dev" style={{ margin: 16 }}>
-        <Button
-          title="Use Generated Wallet with Groups (dev)"
-          color="purple"
-          onPress={() => {
-            configureWallet(
-              'dev',
-              XMTP.Client.createRandom({
-                enableAlphaMls: true,
-                env: 'dev',
+                env: selectedNetwork,
                 appVersion,
                 codecs: supportedCodecs,
                 preCreateIdentityCallback,
                 preEnableIdentityCallback,
+                enableAlphaMls: enableGroups === 'true',
               })
             )
           }}
@@ -241,80 +183,24 @@ export default function LaunchScreen({
       </View>
       {!!savedKeys.keyBundle && (
         <>
-          <Divider key="divider-saved" />
-          <Text
-            style={{
-              fontSize: 16,
-              textAlign: 'right',
-              textTransform: 'uppercase',
-              color: '#333',
-              paddingHorizontal: 16,
-              marginHorizontal: 16,
-            }}
-          >
-            Saved Wallet
-          </Text>
           <View key="saved-dev" style={{ margin: 16 }}>
             <Button
-              title="Use Saved Wallet (dev)"
-              color="green"
-              onPress={() => {
-                configureWallet(
-                  'dev',
-                  XMTP.Client.createFromKeyBundle(savedKeys.keyBundle!, {
-                    env: 'dev',
-                    appVersion,
-                    codecs: supportedCodecs,
-                  })
-                )
-              }}
-            />
-          </View>
-          <View key="saved-local" style={{ margin: 16 }}>
-            <Button
-              title="Use Saved Wallet (local)"
+              title="Use Saved Wallet"
               color="purple"
               onPress={() => {
-                configureWallet(
-                  'local',
-                  XMTP.Client.createFromKeyBundle(savedKeys.keyBundle!, {
-                    env: 'local',
-                    appVersion,
-                    codecs: supportedCodecs,
-                  })
+                console.log(
+                  'Using network ' +
+                    selectedNetwork +
+                    ' and enableAlphaMLS ' +
+                    enableGroups
                 )
-              }}
-            />
-          </View>
-          <View key="saved-groups-local" style={{ margin: 16 }}>
-            <Button
-              title="Use Saved Wallet with Groups (local)"
-              color="purple"
-              onPress={() => {
                 configureWallet(
-                  'local',
+                  selectedNetwork,
                   XMTP.Client.createFromKeyBundle(savedKeys.keyBundle!, {
-                    enableAlphaMls: true,
-                    env: 'local',
-                    appVersion,
-                    codecs: supportedCodecs,
-                  })
-                )
-              }}
-            />
-          </View>
-          <View key="saved-groups-dev" style={{ margin: 16 }}>
-            <Button
-              title="Use Saved Wallet with Groups (dev)"
-              color="purple"
-              onPress={() => {
-                configureWallet(
-                  'dev',
-                  XMTP.Client.createFromKeyBundle(savedKeys.keyBundle!, {
-                    enableAlphaMls: true,
-                    env: 'dev',
+                    env: selectedNetwork,
                     appVersion,
                     codecs: supportedCodecs,
+                    enableAlphaMls: enableGroups === 'true',
                   })
                 )
               }}
@@ -323,7 +209,7 @@ export default function LaunchScreen({
           <View key="saved-clear" style={{ margin: 16 }}>
             <Button
               title="Clear Saved Wallet"
-              // color={"black"}
+              color="red"
               onPress={() => savedKeys.clear()}
             />
           </View>
@@ -333,14 +219,40 @@ export default function LaunchScreen({
   )
 }
 
-function Divider() {
-  return (
-    <View
-      style={{
-        borderBottomColor: 'black',
-        margin: 16,
-        borderBottomWidth: StyleSheet.hairlineWidth,
-      }}
-    />
-  )
-}
+const styles = StyleSheet.create({
+  divider: {
+    borderBottomColor: 'black',
+    margin: 16,
+    borderBottomWidth: StyleSheet.hairlineWidth,
+  },
+  title: {
+    fontSize: 18,
+    textAlign: 'left',
+    textTransform: 'uppercase',
+    color: '#333',
+    marginVertical: 16,
+    paddingHorizontal: 16,
+    marginHorizontal: 16,
+  },
+  row: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    paddingHorizontal: 16,
+    marginHorizontal: 16,
+    backgroundColor: '#fff', // Or any color that fits your app's theme
+    borderBottomWidth: StyleSheet.hairlineWidth,
+    borderBottomColor: '#ccc',
+  },
+  modalSelector: {
+    borderColor: 'black',
+  },
+  modalSelectText: {
+    color: 'black',
+    fontWeight: 'bold',
+  },
+  label: {
+    fontSize: 16,
+    flex: 1,
+  },
+})
diff --git a/example/src/Navigation.tsx b/example/src/Navigation.tsx
index cba743e69..4bd02e12f 100644
--- a/example/src/Navigation.tsx
+++ b/example/src/Navigation.tsx
@@ -2,7 +2,7 @@ import { createNativeStackNavigator } from '@react-navigation/native-stack'
 
 export type NavigationParamList = {
   launch: undefined
-  test: undefined
+  test: { onlyGroups?: boolean }
   home: undefined
   group: { id: string }
   conversation: { topic: string }
diff --git a/example/src/TestScreen.tsx b/example/src/TestScreen.tsx
index f0987cc8b..72fafb1a2 100644
--- a/example/src/TestScreen.tsx
+++ b/example/src/TestScreen.tsx
@@ -1,7 +1,9 @@
+import { useRoute } from '@react-navigation/native'
 import React, { useEffect, useState } from 'react'
 import { View, Text, Button, ScrollView } from 'react-native'
 
-import { tests, Test } from './tests'
+import { groupTests } from './tests/groupTests'
+import { tests, Test } from './tests/tests'
 
 type Result = 'waiting' | 'running' | 'success' | 'failure' | 'error'
 
@@ -97,22 +99,26 @@ function TestView({
 
 export default function TestScreen(): JSX.Element {
   const [completedTests, setCompletedTests] = useState<number>(0)
+  const route = useRoute()
+  const params = route.params as { onlyGroups: boolean }
+  const allTests = tests.concat(groupTests)
+  const activeTests = params.onlyGroups ? groupTests : allTests
 
   return (
     <ScrollView>
       <View>
         <View style={{ padding: 12 }}>
           <Text testID="Test View" accessible accessibilityLabel="Test View">
-            Unit Tests
+            {params.onlyGroups ? 'Group Unit Tests' : 'All Unit Tests'}
           </Text>
           <View
             style={{ flexDirection: 'row', justifyContent: 'space-between' }}
           >
             <Text>
-              Running {completedTests}/{tests.length}
+              Running {completedTests}/{activeTests.length}
             </Text>
 
-            {completedTests === tests.length && (
+            {completedTests === activeTests.length && (
               <Text
                 testID="tests-complete"
                 accessible
@@ -129,17 +135,19 @@ export default function TestScreen(): JSX.Element {
           accessibilityLabel="tests-complete"
           style={{ paddingHorizontal: 12 }}
         >
-          {(tests || []).slice(0, completedTests + 1).map((test: Test, i) => {
-            return (
-              <TestView
-                test={test}
-                onComplete={() => {
-                  setCompletedTests((prev) => prev + 1)
-                }}
-                key={i}
-              />
-            )
-          })}
+          {(activeTests || [])
+            .slice(0, completedTests + 1)
+            .map((test: Test, i) => {
+              return (
+                <TestView
+                  test={test}
+                  onComplete={() => {
+                    setCompletedTests((prev) => prev + 1)
+                  }}
+                  key={i}
+                />
+              )
+            })}
         </View>
       </View>
     </ScrollView>
diff --git a/example/src/tests/groupTests.ts b/example/src/tests/groupTests.ts
new file mode 100644
index 000000000..9816f171a
--- /dev/null
+++ b/example/src/tests/groupTests.ts
@@ -0,0 +1,794 @@
+import { DecodedMessage } from 'xmtp-react-native-sdk/lib/DecodedMessage'
+
+import { Test, assert, delayToPropogate } from './tests'
+import {
+  Client,
+  Conversation,
+  Group,
+  ConversationContainer,
+  ConversationVersion,
+} from '../../../src/index'
+
+export const groupTests: Test[] = []
+
+function test(name: string, perform: () => Promise<boolean>) {
+  groupTests.push({ name, run: perform })
+}
+
+test('can make a MLS V3 client', async () => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const client = await Client.createRandom({
+    env: 'local',
+    appVersion: 'Testing/0.0.0',
+    enableAlphaMls: true,
+  })
+
+  return true
+})
+
+test('can make a MLS V3 client from bundle', async () => {
+  const client = await Client.createRandom({
+    env: 'local',
+    appVersion: 'Testing/0.0.0',
+    enableAlphaMls: true,
+  })
+
+  const anotherClient = await Client.createRandom({
+    env: 'local',
+    appVersion: 'Testing/0.0.0',
+    enableAlphaMls: true,
+  })
+
+  const group1 = await client.conversations.newGroup([anotherClient.address])
+
+  assert(
+    group1.clientAddress === client.address,
+    `clients dont match ${client.address} and ${group1.clientAddress}`
+  )
+
+  const bundle = await client.exportKeyBundle()
+  const client2 = await Client.createFromKeyBundle(bundle, {
+    env: 'local',
+    appVersion: 'Testing/0.0.0',
+    enableAlphaMls: true,
+  })
+
+  assert(
+    client.address === client2.address,
+    `clients dont match ${client2.address} and ${client.address}`
+  )
+
+  const randomClient = await Client.createRandom({
+    env: 'local',
+    appVersion: 'Testing/0.0.0',
+    enableAlphaMls: true,
+  })
+
+  const group = await client2.conversations.newGroup([randomClient.address])
+
+  assert(
+    group.clientAddress === client2.address,
+    `clients dont match ${client2.address} and ${group.clientAddress}`
+  )
+
+  return true
+})
+
+test('production MLS V3 client creation throws error', async () => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const client = await Client.createRandom({
+      env: 'production',
+      appVersion: 'Testing/0.0.0',
+      enableAlphaMls: true,
+    })
+  } catch (error: any) {
+    return true
+  }
+  throw new Error(
+    'should throw error on MLS V3 client create when environment is not local'
+  )
+})
+
+test('can message in a group', async () => {
+  // Create three MLS enabled Clients
+  const aliceClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const bobClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const camClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+
+  // Alice's num groups start at 0
+  let aliceGroups = await aliceClient.conversations.listGroups()
+  if (aliceGroups.length !== 0) {
+    throw new Error('num groups should be 0')
+  }
+
+  // Alice creates a group
+  const aliceGroup = await aliceClient.conversations.newGroup([
+    bobClient.address,
+    camClient.address,
+  ])
+
+  // Alice's num groups == 1
+  aliceGroups = await aliceClient.conversations.listGroups()
+  if (aliceGroups.length !== 1) {
+    throw new Error('num groups should be 1')
+  }
+
+  // Alice group should match create time from list function
+  assert(aliceGroups[0].createdAt === aliceGroup.createdAt, 'group create time')
+
+  // Alice can confirm memberAddresses
+  const memberAddresses = await aliceGroup.memberAddresses()
+  if (memberAddresses.length !== 3) {
+    throw new Error('num group members should be 3')
+  }
+  const lowercasedAddresses: string[] = memberAddresses.map((s) =>
+    s.toLowerCase()
+  )
+  if (
+    !(
+      lowercasedAddresses.includes(aliceClient.address.toLowerCase()) &&
+      lowercasedAddresses.includes(bobClient.address.toLowerCase()) &&
+      lowercasedAddresses.includes(camClient.address.toLowerCase())
+    )
+  ) {
+    throw new Error('missing address')
+  }
+  await bobClient.conversations.syncGroups()
+
+  // Alice can send messages
+  await aliceGroup.send('hello, world')
+  await aliceGroup.send('gm')
+
+  // Bob's num groups == 1
+  const bobGroups = await bobClient.conversations.listGroups()
+  if (bobGroups.length !== 1) {
+    throw new Error(
+      'num groups for bob should be 1, but it is' + bobGroups.length
+    )
+  }
+  delayToPropogate()
+  // Bob can read messages from Alice
+  await bobGroups[0].sync()
+  const bobMessages: DecodedMessage[] = await bobGroups[0].messages()
+
+  if (bobMessages.length !== 2) {
+    throw new Error(
+      'num messages for bob should be 2, but it is' + bobMessages.length
+    )
+  }
+  if (bobMessages[0].content() !== 'gm') {
+    throw new Error("newest message should be 'gm'")
+  }
+  if (bobMessages[1].content() !== 'hello, world') {
+    throw new Error("newest message should be 'hello, world'")
+  }
+  // Bob can send a message
+  bobGroups[0].send('hey guys!')
+
+  // Cam's num groups == 1
+  await camClient.conversations.syncGroups()
+  const camGroups = await camClient.conversations.listGroups()
+  if (camGroups.length !== 1) {
+    throw new Error(
+      'num groups for cam should be 1, but it is' + camGroups.length
+    )
+  }
+
+  // Cam can read messages from Alice and Bob
+  await camGroups[0].sync()
+  const camMessages = await camGroups[0].messages()
+  if (camMessages[1].content() !== 'gm') {
+    throw new Error("second Message should be 'gm'")
+  }
+  if (camMessages[0].content() !== 'hey guys!') {
+    throw new Error("newest Message should be 'hey guys!'")
+  }
+
+  return true
+})
+
+test('can add members to a group', async () => {
+  // Create three MLS enabled Clients
+  const aliceClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const bobClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const camClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+
+  // Alice's num groups start at 0
+  let aliceGroups = await aliceClient.conversations.listGroups()
+  if (aliceGroups.length !== 0) {
+    throw new Error('num groups should be 0')
+  }
+
+  // Bob's num groups start at 0
+  let bobGroups = await bobClient.conversations.listGroups()
+  if (bobGroups.length !== 0) {
+    throw new Error('num groups should be 0')
+  }
+
+  // Cam's num groups start at 0
+  let camGroups = await camClient.conversations.listGroups()
+  if (camGroups.length !== 0) {
+    throw new Error('num groups should be 0')
+  }
+
+  // Alice creates a group
+  const aliceGroup = await aliceClient.conversations.newGroup([
+    bobClient.address,
+  ])
+
+  // Alice's num groups == 1
+  aliceGroups = await aliceClient.conversations.listGroups()
+  if (aliceGroups.length !== 1) {
+    throw new Error('num groups should be 1')
+  }
+
+  // Alice can confirm memberAddresses
+  const memberAddresses = await aliceGroup.memberAddresses()
+  if (memberAddresses.length !== 2) {
+    throw new Error('num group members should be 2')
+  }
+  const lowercasedAddresses: string[] = memberAddresses.map((s) =>
+    s.toLowerCase()
+  )
+  if (
+    !(
+      lowercasedAddresses.includes(aliceClient.address.toLowerCase()) &&
+      lowercasedAddresses.includes(bobClient.address.toLowerCase())
+    )
+  ) {
+    throw new Error('missing address')
+  }
+
+  // Alice can send messages
+  aliceGroup.send('hello, world')
+  aliceGroup.send('gm')
+
+  // Bob's num groups == 1
+  await bobClient.conversations.syncGroups()
+  bobGroups = await bobClient.conversations.listGroups()
+  if (bobGroups.length !== 1) {
+    throw new Error(
+      'num groups for bob should be 1, but it is' + bobGroups.length
+    )
+  }
+
+  await aliceGroup.addMembers([camClient.address])
+
+  // Cam's num groups == 1
+  await camClient.conversations.syncGroups()
+  camGroups = await camClient.conversations.listGroups()
+  if (camGroups.length !== 1) {
+    throw new Error(
+      'num groups for cam should be 1, but it is' + camGroups.length
+    )
+  }
+  const camMessages = await camGroups[0].messages()
+  if (camMessages.length !== 0) {
+    throw new Error('num messages for cam should be 0')
+  }
+
+  await bobGroups[0].sync()
+  const bobGroupMembers = await bobGroups[0].memberAddresses()
+  if (bobGroupMembers.length !== 3) {
+    throw new Error('num group members should be 3')
+  }
+
+  return true
+})
+
+test('can remove members from a group', async () => {
+  // Create three MLS enabled Clients
+  const aliceClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const bobClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const camClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+
+  // Alice's num groups start at 0
+  let aliceGroups = await aliceClient.conversations.listGroups()
+  if (aliceGroups.length !== 0) {
+    throw new Error('num groups should be 0')
+  }
+
+  // Bob's num groups start at 0
+  let bobGroups = await bobClient.conversations.listGroups()
+  assert(bobGroups.length === 0, 'num groups should be 0')
+
+  // Cam's num groups start at 0
+  let camGroups = await camClient.conversations.listGroups()
+  if (camGroups.length !== 0) {
+    throw new Error('num groups should be 0')
+  }
+
+  // Alice creates a group
+  const aliceGroup = await aliceClient.conversations.newGroup([
+    bobClient.address,
+    camClient.address,
+  ])
+
+  // Alice's num groups == 1
+  aliceGroups = await aliceClient.conversations.listGroups()
+  if (aliceGroups.length !== 1) {
+    throw new Error('num groups should be 1')
+  }
+
+  // Alice can confirm memberAddresses
+  const memberAddresses = await aliceGroup.memberAddresses()
+  if (memberAddresses.length !== 3) {
+    throw new Error('num group members should be 3')
+  }
+  const lowercasedAddresses: string[] = memberAddresses.map((s) =>
+    s.toLowerCase()
+  )
+  if (
+    !(
+      lowercasedAddresses.includes(aliceClient.address.toLowerCase()) &&
+      lowercasedAddresses.includes(bobClient.address.toLowerCase())
+    )
+  ) {
+    throw new Error('missing address')
+  }
+
+  // Alice can send messages
+  await aliceGroup.send('hello, world')
+  await aliceGroup.send('gm')
+
+  // Bob's num groups == 1
+  await bobClient.conversations.syncGroups()
+  bobGroups = await bobClient.conversations.listGroups()
+  if (bobGroups.length !== 1) {
+    throw new Error(
+      'num groups for bob should be 1, but it is' + bobGroups.length
+    )
+  }
+
+  // Cam's num groups == 1
+  await camClient.conversations.syncGroups()
+  camGroups = await camClient.conversations.listGroups()
+  if (camGroups.length !== 1) {
+    throw new Error(
+      'num groups for cam should be 1, but it is' + camGroups.length
+    )
+  }
+
+  if (!camGroups[0].isActive()) {
+    throw new Error('cams group should be active')
+  }
+
+  await aliceGroup.removeMembers([camClient.address])
+  await aliceGroup.sync()
+  const aliceGroupMembers = await aliceGroup.memberAddresses()
+  if (aliceGroupMembers.length !== 2) {
+    throw new Error('num group members should be 2')
+  }
+
+  // await bobClient.conversations.syncGroups()
+
+  // bobGroups = await bobClient.conversations.listGroups()
+  // await bobGroups[0].sync()
+  // const bobGroupMessages = await bobGroups[0].messages()
+  // if (bobGroups.length !== 0) {
+  //   throw new Error(
+  //     'num groups for bob should be 0, but it is ' + bobGroups.length
+  //   )
+  // }
+
+  await camGroups[0].sync()
+  await camClient.conversations.syncGroups()
+
+  if (await camGroups[0].isActive()) {
+    throw new Error('cams group should not be active')
+  }
+
+  const camGroupMembers = await camGroups[0].memberAddresses()
+  if (camGroupMembers.length !== 2) {
+    throw new Error('num group members should be 2')
+  }
+
+  return true
+})
+
+test('can stream groups', async () => {
+  // Create three MLS enabled Clients
+  const aliceClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const bobClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const camClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+
+  // Start streaming groups
+  const groups: Group<any>[] = []
+  const cancelStreamGroups = await aliceClient.conversations.streamGroups(
+    async (group: Group<any>) => {
+      groups.push(group)
+    }
+  )
+
+  // Cam creates a group with Alice, so stream callback is fired
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const camGroup = await camClient.conversations.newGroup([aliceClient.address])
+  await delayToPropogate()
+  if ((groups.length as number) !== 1) {
+    throw Error('Unexpected num groups (should be 1): ' + groups.length)
+  }
+
+  // Bob creates a group with Alice so a stream callback is fired
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const bobgroup = await bobClient.conversations.newGroup([aliceClient.address])
+  await delayToPropogate()
+  if ((groups.length as number) !== 2) {
+    throw Error('Unexpected num groups (should be 2): ' + groups.length)
+  }
+
+  // * Note Alice creating a group does not trigger alice conversations
+  // group stream. Workaround is to syncGroups after you create and list manually
+
+  // Alice creates a group
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const aliceGroup = await aliceClient.conversations.newGroup([
+    bobClient.address,
+    camClient.address,
+  ])
+  await delayToPropogate()
+  if (groups.length !== 2) {
+    throw Error('Expected group length 2 but it is: ' + groups.length)
+  }
+  // Sync groups after creation if you created a group
+  await aliceClient.conversations.syncGroups()
+  const listedGroups = await aliceClient.conversations.listGroups()
+  await delayToPropogate()
+  groups.push(listedGroups[listedGroups.length - 1])
+  if ((groups.length as number) !== 3) {
+    throw Error('Expected group length 3 but it is: ' + groups.length)
+  }
+
+  cancelStreamGroups()
+  await delayToPropogate()
+
+  // Creating a group should no longer trigger stream groups
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const camSecond = await camClient.conversations.newGroup([
+    aliceClient.address,
+  ])
+  await delayToPropogate()
+  if ((groups.length as number) !== 3) {
+    throw Error('Unexpected num groups (should be 3): ' + groups.length)
+  }
+
+  return true
+})
+
+test('can list all groups', async () => {
+  // Create three MLS enabled Clients
+  const aliceClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  delayToPropogate()
+  const bobClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  delayToPropogate()
+  const camClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  delayToPropogate()
+  const bobGroup = await bobClient.conversations.newGroup([aliceClient.address])
+  const aliceGroup = await aliceClient.conversations.newGroup([
+    camClient.address,
+  ])
+
+  await aliceClient.conversations.syncGroups()
+  delayToPropogate
+
+  const listedGroups = await aliceClient.conversations.listGroups()
+  console.log('BREAK')
+
+  console.log('listedGroups[0].createdAt', listedGroups[0].createdAt)
+  console.log('bob.createdAt', bobGroup.createdAt)
+  console.log('listedGroups[0].createdAt', listedGroups[1].createdAt)
+  console.log('alice.createdAt', aliceGroup.createdAt)
+
+  console.log('BREAK')
+
+  return true
+})
+
+test('can list all groups and conversations', async () => {
+  // Create three MLS enabled Clients
+  const aliceClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const bobClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const camClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+
+  // Add one group and one conversation
+  const bobGroup = await bobClient.conversations.newGroup([aliceClient.address])
+  const aliceConversation = await aliceClient.conversations.newConversation(
+    camClient.address
+  )
+
+  const listedContainers = await aliceClient.conversations.listAll()
+
+  // Verify information in listed containers is correct
+  if (
+    listedContainers[0].topic !== bobGroup.topic ||
+    listedContainers[0].version !== ConversationVersion.GROUP ||
+    listedContainers[1].version !== ConversationVersion.DIRECT ||
+    listedContainers[1].createdAt !== aliceConversation.createdAt
+  ) {
+    throw Error('Listed containers should match streamed containers')
+  }
+
+  return true
+})
+
+test('can stream all groups and conversations', async () => {
+  // Create three MLS enabled Clients
+  const aliceClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const bobClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const camClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+
+  // Start streaming groups and conversations
+  const containers: ConversationContainer<any>[] = []
+  const cancelStreamAll = await aliceClient.conversations.streamAll(
+    async (conversationContainer: ConversationContainer<any>) => {
+      containers.push(conversationContainer)
+    }
+  )
+
+  // Bob creates a group with Alice, so stream callback is fired
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const bobGroup = await bobClient.conversations.newGroup([aliceClient.address])
+  await delayToPropogate()
+  if ((containers.length as number) !== 1) {
+    throw Error('Unexpected num groups (should be 1): ' + containers.length)
+  }
+  if (containers[0].version === ConversationVersion.GROUP) {
+    ;(containers[0] as Group).sync()
+  } else {
+    console.log(JSON.stringify(containers[0] as Group))
+    throw Error('Unexpected first ConversationContainer should be a group')
+  }
+
+  // Bob creates a v2 Conversation with Alice so a stream callback is fired
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const bobConversation = await bobClient.conversations.newConversation(
+    aliceClient.address
+  )
+  await delayToPropogate()
+  if ((containers.length as number) !== 2) {
+    throw Error('Unexpected num groups (should be 2): ' + containers.length)
+  }
+
+  if (
+    containers[1].version === ConversationVersion.DIRECT &&
+    bobConversation.conversationID !==
+      (containers[1] as Conversation<any>).conversationID
+  ) {
+    throw Error(
+      'Conversation from streamed all should match conversationID with created conversation'
+    )
+  }
+
+  // * Note Alice creating a v2 Conversation does trigger alice conversations
+  // stream.
+
+  // Alice creates a V2 Conversationgroup
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const aliceConversation = await aliceClient.conversations.newConversation(
+    camClient.address
+  )
+  await delayToPropogate()
+  if (containers.length !== 3) {
+    throw Error('Expected group length 3 but it is: ' + containers.length)
+  }
+
+  cancelStreamAll()
+  await delayToPropogate()
+
+  // Creating a group should no longer trigger stream groups
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const camConversation = await camClient.conversations.newGroup([
+    aliceClient.address,
+  ])
+  await delayToPropogate()
+  if ((containers.length as number) !== 3) {
+    throw Error('Unexpected num groups (should be 3): ' + containers.length)
+  }
+
+  return true
+})
+
+test('canMessage', async () => {
+  const bo = await Client.createRandom({ env: 'local' })
+  const alix = await Client.createRandom({ env: 'local' })
+
+  const canMessage = await bo.canMessage(alix.address)
+  if (!canMessage) {
+    throw new Error('should be able to message v2 client')
+  }
+
+  const caro = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const chux = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+
+  const canMessageV3 = await caro.canGroupMessage([chux.address])
+  if (!canMessageV3) {
+    throw new Error('should be able to message v3 client')
+  }
+  return true
+})
+
+test('can stream group messages', async () => {
+  // Create three MLS enabled Clients
+  const aliceClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const bobClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+  const camClient = await Client.createRandom({
+    env: 'local',
+    enableAlphaMls: true,
+  })
+
+  // Alice creates a group
+  const aliceGroup = await aliceClient.conversations.newGroup([
+    bobClient.address,
+    camClient.address,
+  ])
+
+  // Record message stream for this group
+  const groupMessages: DecodedMessage[] = []
+  const cancelGroupMessageStream = await aliceGroup.streamGroupMessages(
+    async (message) => {
+      groupMessages.push(message)
+    }
+  )
+
+  // Bob's num groups == 1
+  await bobClient.conversations.syncGroups()
+  const bobGroup = (await bobClient.conversations.listGroups())[0]
+
+  for (let i = 0; i < 5; i++) {
+    await bobGroup.send({ text: `Message ${i}` })
+    await delayToPropogate()
+  }
+
+  if (groupMessages.length !== 5) {
+    throw Error('Unexpected convo messages count ' + groupMessages.length)
+  }
+  for (let i = 0; i < 5; i++) {
+    if (groupMessages[i].content() !== `Message ${i}`) {
+      throw Error(
+        'Unexpected group message content ' + groupMessages[i].content()
+      )
+    }
+  }
+
+  cancelGroupMessageStream()
+  for (let i = 0; i < 5; i++) {
+    await bobGroup.send({ text: `Message ${i}` })
+  }
+
+  if (groupMessages.length !== 5) {
+    throw Error('Unexpected convo messages count ' + groupMessages.length)
+  }
+
+  return true
+})
+
+test('can stream all messages', async () => {
+  const bo = await Client.createRandom({ env: 'local' })
+  await delayToPropogate()
+  const alix = await Client.createRandom({ env: 'local' })
+  await delayToPropogate()
+
+  // Record message stream across all conversations
+  const allMessages: DecodedMessage[] = []
+  await alix.conversations.streamAllMessages(async (message) => {
+    allMessages.push(message)
+  })
+
+  // Start Bob starts a new conversation.
+  const boConvo = await bo.conversations.newConversation(alix.address)
+  await delayToPropogate()
+
+  for (let i = 0; i < 5; i++) {
+    await boConvo.send({ text: `Message ${i}` })
+    await delayToPropogate()
+  }
+
+  const count = allMessages.length
+  if (count !== 5) {
+    throw Error('Unexpected all messages count ' + allMessages.length)
+  }
+
+  // Starts a new conversation.
+  const caro = await Client.createRandom({ env: 'local' })
+  const caroConvo = await caro.conversations.newConversation(alix.address)
+  await delayToPropogate()
+  for (let i = 0; i < 5; i++) {
+    await caroConvo.send({ text: `Message ${i}` })
+    await delayToPropogate()
+  }
+
+  if (allMessages.length !== 10) {
+    throw Error('Unexpected all messages count ' + allMessages.length)
+  }
+
+  alix.conversations.cancelStreamAllMessages()
+
+  await alix.conversations.streamAllMessages(async (message) => {
+    allMessages.push(message)
+  })
+
+  for (let i = 0; i < 5; i++) {
+    await boConvo.send({ text: `Message ${i}` })
+    await delayToPropogate()
+  }
+  if (allMessages.length <= 10) {
+    throw Error('Unexpected all messages count ' + allMessages.length)
+  }
+
+  return true
+})
diff --git a/example/src/tests.ts b/example/src/tests/tests.ts
similarity index 56%
rename from example/src/tests.ts
rename to example/src/tests/tests.ts
index c5f061678..79204dca8 100644
--- a/example/src/tests.ts
+++ b/example/src/tests/tests.ts
@@ -12,10 +12,7 @@ import {
   StaticAttachmentCodec,
   RemoteAttachmentCodec,
   RemoteAttachmentContent,
-  Group,
-  ConversationContainer,
-  ConversationVersion,
-} from '../../src/index'
+} from '../../../src/index'
 
 type EncodedContent = content.EncodedContent
 type ContentTypeId = content.ContentTypeId
@@ -71,13 +68,13 @@ export type Test = {
 
 export const tests: Test[] = []
 
-function assert(condition: boolean, msg: string) {
+export function assert(condition: boolean, msg: string) {
   if (!condition) {
     throw new Error(msg)
   }
 }
 
-async function delayToPropogate(): Promise<void> {
+export async function delayToPropogate(): Promise<void> {
   // delay 1s to avoid clobbering
   return new Promise((r) => setTimeout(r, 100))
 }
@@ -102,606 +99,6 @@ test('can make a client', async () => {
   return client.address.length > 0
 })
 
-test('can make a MLS V3 client', async () => {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const client = await Client.createRandom({
-    env: 'local',
-    appVersion: 'Testing/0.0.0',
-    enableAlphaMls: true,
-  })
-
-  return true
-})
-
-test('can make a MLS V3 client from bundle', async () => {
-  const client = await Client.createRandom({
-    env: 'local',
-    appVersion: 'Testing/0.0.0',
-    enableAlphaMls: true,
-  })
-
-  const anotherClient = await Client.createRandom({
-    env: 'local',
-    appVersion: 'Testing/0.0.0',
-    enableAlphaMls: true,
-  })
-
-  const group1 = await client.conversations.newGroup([anotherClient.address])
-
-  if (group1.clientAddress !== client.address) {
-    throw new Error(
-      `clients dont match ${client.address} and ${group1.clientAddress}`
-    )
-  }
-  const bundle = await client.exportKeyBundle()
-
-  const client2 = await Client.createFromKeyBundle(bundle, {
-    env: 'local',
-    appVersion: 'Testing/0.0.0',
-    enableAlphaMls: true,
-  })
-
-  if (client.address !== client2.address) {
-    throw new Error(
-      `clients dont match ${client2.address} and ${client.address}`
-    )
-  }
-
-  const randomClient = await Client.createRandom({
-    env: 'local',
-    appVersion: 'Testing/0.0.0',
-    enableAlphaMls: true,
-  })
-
-  const group = await client2.conversations.newGroup([randomClient.address])
-
-  if (group.clientAddress !== client2.address) {
-    throw new Error(
-      `clients dont match ${client2.address} and ${group.clientAddress}`
-    )
-  }
-
-  return true
-})
-
-test('production MLS V3 client creation throws error', async () => {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const client = await Client.createRandom({
-      env: 'production',
-      appVersion: 'Testing/0.0.0',
-      enableAlphaMls: true,
-    })
-  } catch (error: any) {
-    return true
-  }
-  throw new Error(
-    'should throw error on MLS V3 client create when environment is not local'
-  )
-})
-
-test('can message in a group', async () => {
-  // Create three MLS enabled Clients
-  const aliceClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const bobClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const camClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-
-  // Alice's num groups start at 0
-  let aliceGroups = await aliceClient.conversations.listGroups()
-  if (aliceGroups.length !== 0) {
-    throw new Error('num groups should be 0')
-  }
-
-  // Alice creates a group
-  const aliceGroup = await aliceClient.conversations.newGroup([
-    bobClient.address,
-    camClient.address,
-  ])
-
-  // Alice's num groups == 1
-  aliceGroups = await aliceClient.conversations.listGroups()
-  if (aliceGroups.length !== 1) {
-    throw new Error('num groups should be 1')
-  }
-
-  // Alice can confirm memberAddresses
-  const memberAddresses = await aliceGroup.memberAddresses()
-  if (memberAddresses.length !== 3) {
-    throw new Error('num group members should be 3')
-  }
-  const lowercasedAddresses: string[] = memberAddresses.map((s) =>
-    s.toLowerCase()
-  )
-  if (
-    !(
-      lowercasedAddresses.includes(aliceClient.address.toLowerCase()) &&
-      lowercasedAddresses.includes(bobClient.address.toLowerCase()) &&
-      lowercasedAddresses.includes(camClient.address.toLowerCase())
-    )
-  ) {
-    throw new Error('missing address')
-  }
-  await bobClient.conversations.syncGroups()
-
-  // Alice can send messages
-  await aliceGroup.send('hello, world')
-  await aliceGroup.send('gm')
-
-  // Bob's num groups == 1
-  const bobGroups = await bobClient.conversations.listGroups()
-  if (bobGroups.length !== 1) {
-    throw new Error(
-      'num groups for bob should be 1, but it is' + bobGroups.length
-    )
-  }
-  delayToPropogate()
-  // Bob can read messages from Alice
-  await bobGroups[0].sync()
-  const bobMessages: DecodedMessage[] = await bobGroups[0].messages()
-
-  if (bobMessages.length !== 2) {
-    throw new Error(
-      'num messages for bob should be 2, but it is' + bobMessages.length
-    )
-  }
-  if (bobMessages[0].content() !== 'gm') {
-    throw new Error("newest message should be 'gm'")
-  }
-  if (bobMessages[1].content() !== 'hello, world') {
-    throw new Error("newest message should be 'hello, world'")
-  }
-  // Bob can send a message
-  bobGroups[0].send('hey guys!')
-
-  // Cam's num groups == 1
-  await camClient.conversations.syncGroups()
-  const camGroups = await camClient.conversations.listGroups()
-  if (camGroups.length !== 1) {
-    throw new Error(
-      'num groups for cam should be 1, but it is' + camGroups.length
-    )
-  }
-
-  // Cam can read messages from Alice and Bob
-  await camGroups[0].sync()
-  const camMessages = await camGroups[0].messages()
-  if (camMessages[1].content() !== 'gm') {
-    throw new Error("second Message should be 'gm'")
-  }
-  if (camMessages[0].content() !== 'hey guys!') {
-    throw new Error("newest Message should be 'hey guys!'")
-  }
-
-  return true
-})
-
-test('can add members to a group', async () => {
-  // Create three MLS enabled Clients
-  const aliceClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const bobClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const camClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-
-  // Alice's num groups start at 0
-  let aliceGroups = await aliceClient.conversations.listGroups()
-  if (aliceGroups.length !== 0) {
-    throw new Error('num groups should be 0')
-  }
-
-  // Bob's num groups start at 0
-  let bobGroups = await bobClient.conversations.listGroups()
-  if (bobGroups.length !== 0) {
-    throw new Error('num groups should be 0')
-  }
-
-  // Cam's num groups start at 0
-  let camGroups = await camClient.conversations.listGroups()
-  if (camGroups.length !== 0) {
-    throw new Error('num groups should be 0')
-  }
-
-  // Alice creates a group
-  const aliceGroup = await aliceClient.conversations.newGroup([
-    bobClient.address,
-  ])
-
-  // Alice's num groups == 1
-  aliceGroups = await aliceClient.conversations.listGroups()
-  if (aliceGroups.length !== 1) {
-    throw new Error('num groups should be 1')
-  }
-
-  // Alice can confirm memberAddresses
-  const memberAddresses = await aliceGroup.memberAddresses()
-  if (memberAddresses.length !== 2) {
-    throw new Error('num group members should be 2')
-  }
-  const lowercasedAddresses: string[] = memberAddresses.map((s) =>
-    s.toLowerCase()
-  )
-  if (
-    !(
-      lowercasedAddresses.includes(aliceClient.address.toLowerCase()) &&
-      lowercasedAddresses.includes(bobClient.address.toLowerCase())
-    )
-  ) {
-    throw new Error('missing address')
-  }
-
-  // Alice can send messages
-  aliceGroup.send('hello, world')
-  aliceGroup.send('gm')
-
-  // Bob's num groups == 1
-  await bobClient.conversations.syncGroups()
-  bobGroups = await bobClient.conversations.listGroups()
-  if (bobGroups.length !== 1) {
-    throw new Error(
-      'num groups for bob should be 1, but it is' + bobGroups.length
-    )
-  }
-
-  await aliceGroup.addMembers([camClient.address])
-
-  // Cam's num groups == 1
-  await camClient.conversations.syncGroups()
-  camGroups = await camClient.conversations.listGroups()
-  if (camGroups.length !== 1) {
-    throw new Error(
-      'num groups for cam should be 1, but it is' + camGroups.length
-    )
-  }
-  const camMessages = await camGroups[0].messages()
-  if (camMessages.length !== 0) {
-    throw new Error('num messages for cam should be 0')
-  }
-
-  await bobGroups[0].sync()
-  const bobGroupMembers = await bobGroups[0].memberAddresses()
-  if (bobGroupMembers.length !== 3) {
-    throw new Error('num group members should be 3')
-  }
-
-  return true
-})
-
-test('can remove members from a group', async () => {
-  // Create three MLS enabled Clients
-  const aliceClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const bobClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const camClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-
-  // Alice's num groups start at 0
-  let aliceGroups = await aliceClient.conversations.listGroups()
-  if (aliceGroups.length !== 0) {
-    throw new Error('num groups should be 0')
-  }
-
-  // Bob's num groups start at 0
-  let bobGroups = await bobClient.conversations.listGroups()
-  if (bobGroups.length !== 0) {
-    throw new Error('num groups should be 0')
-  }
-
-  // Cam's num groups start at 0
-  let camGroups = await camClient.conversations.listGroups()
-  if (camGroups.length !== 0) {
-    throw new Error('num groups should be 0')
-  }
-
-  // Alice creates a group
-  const aliceGroup = await aliceClient.conversations.newGroup([
-    bobClient.address,
-    camClient.address,
-  ])
-
-  // Alice's num groups == 1
-  aliceGroups = await aliceClient.conversations.listGroups()
-  if (aliceGroups.length !== 1) {
-    throw new Error('num groups should be 1')
-  }
-
-  // Alice can confirm memberAddresses
-  const memberAddresses = await aliceGroup.memberAddresses()
-  if (memberAddresses.length !== 3) {
-    throw new Error('num group members should be 3')
-  }
-  const lowercasedAddresses: string[] = memberAddresses.map((s) =>
-    s.toLowerCase()
-  )
-  if (
-    !(
-      lowercasedAddresses.includes(aliceClient.address.toLowerCase()) &&
-      lowercasedAddresses.includes(bobClient.address.toLowerCase())
-    )
-  ) {
-    throw new Error('missing address')
-  }
-
-  // Alice can send messages
-  await aliceGroup.send('hello, world')
-  await aliceGroup.send('gm')
-
-  // Bob's num groups == 1
-  await bobClient.conversations.syncGroups()
-  bobGroups = await bobClient.conversations.listGroups()
-  if (bobGroups.length !== 1) {
-    throw new Error(
-      'num groups for bob should be 1, but it is' + bobGroups.length
-    )
-  }
-
-  // Cam's num groups == 1
-  await camClient.conversations.syncGroups()
-  camGroups = await camClient.conversations.listGroups()
-  if (camGroups.length !== 1) {
-    throw new Error(
-      'num groups for cam should be 1, but it is' + camGroups.length
-    )
-  }
-
-  if (!camGroups[0].isActive()) {
-    throw new Error('cams group should be active')
-  }
-
-  await aliceGroup.removeMembers([camClient.address])
-  await aliceGroup.sync()
-  const aliceGroupMembers = await aliceGroup.memberAddresses()
-  if (aliceGroupMembers.length !== 2) {
-    throw new Error('num group members should be 2')
-  }
-
-  // await bobClient.conversations.syncGroups()
-
-  // bobGroups = await bobClient.conversations.listGroups()
-  // await bobGroups[0].sync()
-  // const bobGroupMessages = await bobGroups[0].messages()
-  // if (bobGroups.length !== 0) {
-  //   throw new Error(
-  //     'num groups for bob should be 0, but it is ' + bobGroups.length
-  //   )
-  // }
-
-  await camGroups[0].sync()
-  await camClient.conversations.syncGroups()
-
-  if (await camGroups[0].isActive()) {
-    throw new Error('cams group should not be active')
-  }
-
-  const camGroupMembers = await camGroups[0].memberAddresses()
-  if (camGroupMembers.length !== 2) {
-    throw new Error('num group members should be 2')
-  }
-
-  return true
-})
-
-test('can stream groups', async () => {
-  // Create three MLS enabled Clients
-  const aliceClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const bobClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const camClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-
-  // Start streaming groups
-  const groups: Group<any>[] = []
-  const cancelStreamGroups = await aliceClient.conversations.streamGroups(
-    async (group: Group<any>) => {
-      groups.push(group)
-    }
-  )
-
-  // Cam creates a group with Alice, so stream callback is fired
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const camGroup = await camClient.conversations.newGroup([aliceClient.address])
-  await delayToPropogate()
-  if ((groups.length as number) !== 1) {
-    throw Error('Unexpected num groups (should be 1): ' + groups.length)
-  }
-
-  // Bob creates a group with Alice so a stream callback is fired
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const bobgroup = await bobClient.conversations.newGroup([aliceClient.address])
-  await delayToPropogate()
-  if ((groups.length as number) !== 2) {
-    throw Error('Unexpected num groups (should be 2): ' + groups.length)
-  }
-
-  // * Note Alice creating a group does not trigger alice conversations
-  // group stream. Workaround is to syncGroups after you create and list manually
-
-  // Alice creates a group
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const aliceGroup = await aliceClient.conversations.newGroup([
-    bobClient.address,
-    camClient.address,
-  ])
-  await delayToPropogate()
-  if (groups.length !== 2) {
-    throw Error('Expected group length 2 but it is: ' + groups.length)
-  }
-  // Sync groups after creation if you created a group
-  await aliceClient.conversations.syncGroups()
-  const listedGroups = await aliceClient.conversations.listGroups()
-  await delayToPropogate()
-  groups.push(listedGroups[listedGroups.length - 1])
-  if ((groups.length as number) !== 3) {
-    throw Error('Expected group length 3 but it is: ' + groups.length)
-  }
-
-  cancelStreamGroups()
-  await delayToPropogate()
-
-  // Creating a group should no longer trigger stream groups
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const camSecond = await camClient.conversations.newGroup([
-    aliceClient.address,
-  ])
-  await delayToPropogate()
-  if ((groups.length as number) !== 3) {
-    throw Error('Unexpected num groups (should be 3): ' + groups.length)
-  }
-
-  return true
-})
-
-test('can list all groups and conversations', async () => {
-  // Create three MLS enabled Clients
-  const aliceClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const bobClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const camClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-
-  // Add one group and one conversation
-  const bobGroup = await bobClient.conversations.newGroup([aliceClient.address])
-  const aliceConversation = await aliceClient.conversations.newConversation(
-    camClient.address
-  )
-
-  const listedContainers = await aliceClient.conversations.listAll()
-
-  // Verify information in listed containers is correct
-  if (
-    listedContainers[0].topic !== bobGroup.topic ||
-    listedContainers[0].version !== ConversationVersion.GROUP ||
-    listedContainers[1].version !== ConversationVersion.DIRECT ||
-    listedContainers[1].createdAt !== aliceConversation.createdAt
-  ) {
-    throw Error('Listed containers should match streamed containers')
-  }
-
-  return true
-})
-
-test('can stream all groups and conversations', async () => {
-  // Create three MLS enabled Clients
-  const aliceClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const bobClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const camClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-
-  // Start streaming groups and conversations
-  const containers: ConversationContainer<any>[] = []
-  const cancelStreamAll = await aliceClient.conversations.streamAll(
-    async (conversationContainer: ConversationContainer<any>) => {
-      containers.push(conversationContainer)
-    }
-  )
-
-  // Bob creates a group with Alice, so stream callback is fired
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const bobGroup = await bobClient.conversations.newGroup([aliceClient.address])
-  await delayToPropogate()
-  if ((containers.length as number) !== 1) {
-    throw Error('Unexpected num groups (should be 1): ' + containers.length)
-  }
-  if (containers[0].version === ConversationVersion.GROUP) {
-    ;(containers[0] as Group).sync()
-  } else {
-    console.log(JSON.stringify(containers[0] as Group))
-    throw Error('Unexpected first ConversationContainer should be a group')
-  }
-
-  // Bob creates a v2 Conversation with Alice so a stream callback is fired
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const bobConversation = await bobClient.conversations.newConversation(
-    aliceClient.address
-  )
-  await delayToPropogate()
-  if ((containers.length as number) !== 2) {
-    throw Error('Unexpected num groups (should be 2): ' + containers.length)
-  }
-
-  if (
-    containers[1].version === ConversationVersion.DIRECT &&
-    bobConversation.conversationID !==
-      (containers[1] as Conversation<any>).conversationID
-  ) {
-    throw Error(
-      'Conversation from streamed all should match conversationID with created conversation'
-    )
-  }
-
-  // * Note Alice creating a v2 Conversation does trigger alice conversations
-  // stream.
-
-  // Alice creates a V2 Conversationgroup
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const aliceConversation = await aliceClient.conversations.newConversation(
-    camClient.address
-  )
-  await delayToPropogate()
-  if (containers.length !== 3) {
-    throw Error('Expected group length 3 but it is: ' + containers.length)
-  }
-
-  cancelStreamAll()
-  await delayToPropogate()
-
-  // Creating a group should no longer trigger stream groups
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const camConversation = await camClient.conversations.newGroup([
-    aliceClient.address,
-  ])
-  await delayToPropogate()
-  if ((containers.length as number) !== 3) {
-    throw Error('Unexpected num groups (should be 3): ' + containers.length)
-  }
-
-  return true
-})
-
 test('can pass a custom filter date and receive message objects with expected dates', async () => {
   try {
     const bob = await Client.createRandom({ env: 'local' })
@@ -1105,67 +502,6 @@ test('can stream messages', async () => {
   return true
 })
 
-test('can stream group messages', async () => {
-  // Create three MLS enabled Clients
-  const aliceClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const bobClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-  const camClient = await Client.createRandom({
-    env: 'local',
-    enableAlphaMls: true,
-  })
-
-  // Alice creates a group
-  const aliceGroup = await aliceClient.conversations.newGroup([
-    bobClient.address,
-    camClient.address,
-  ])
-
-  // Record message stream for this group
-  const groupMessages: DecodedMessage[] = []
-  const cancelGroupMessageStream = await aliceGroup.streamGroupMessages(
-    async (message) => {
-      groupMessages.push(message)
-    }
-  )
-
-  // Bob's num groups == 1
-  await bobClient.conversations.syncGroups()
-  const bobGroup = (await bobClient.conversations.listGroups())[0]
-
-  for (let i = 0; i < 5; i++) {
-    await bobGroup.send({ text: `Message ${i}` })
-    await delayToPropogate()
-  }
-
-  if (groupMessages.length !== 5) {
-    throw Error('Unexpected convo messages count ' + groupMessages.length)
-  }
-  for (let i = 0; i < 5; i++) {
-    if (groupMessages[i].content() !== `Message ${i}`) {
-      throw Error(
-        'Unexpected group message content ' + groupMessages[i].content()
-      )
-    }
-  }
-
-  cancelGroupMessageStream()
-  for (let i = 0; i < 5; i++) {
-    await bobGroup.send({ text: `Message ${i}` })
-  }
-
-  if (groupMessages.length !== 5) {
-    throw Error('Unexpected convo messages count ' + groupMessages.length)
-  }
-
-  return true
-})
-
 test('remote attachments should work', async () => {
   const alice = await Client.createRandom({
     env: 'local',
@@ -1291,62 +627,6 @@ test('can send read receipts', async () => {
   return true
 })
 
-test('can stream all messages', async () => {
-  const bo = await Client.createRandom({ env: 'local' })
-  await delayToPropogate()
-  const alix = await Client.createRandom({ env: 'local' })
-  await delayToPropogate()
-
-  // Record message stream across all conversations
-  const allMessages: DecodedMessage[] = []
-  await alix.conversations.streamAllMessages(async (message) => {
-    allMessages.push(message)
-  })
-
-  // Start Bob starts a new conversation.
-  const boConvo = await bo.conversations.newConversation(alix.address)
-  await delayToPropogate()
-
-  for (let i = 0; i < 5; i++) {
-    await boConvo.send({ text: `Message ${i}` })
-    await delayToPropogate()
-  }
-
-  const count = allMessages.length
-  if (count !== 5) {
-    throw Error('Unexpected all messages count ' + allMessages.length)
-  }
-
-  // Starts a new conversation.
-  const caro = await Client.createRandom({ env: 'local' })
-  const caroConvo = await caro.conversations.newConversation(alix.address)
-  await delayToPropogate()
-  for (let i = 0; i < 5; i++) {
-    await caroConvo.send({ text: `Message ${i}` })
-    await delayToPropogate()
-  }
-
-  if (allMessages.length !== 10) {
-    throw Error('Unexpected all messages count ' + allMessages.length)
-  }
-
-  alix.conversations.cancelStreamAllMessages()
-
-  await alix.conversations.streamAllMessages(async (message) => {
-    allMessages.push(message)
-  })
-
-  for (let i = 0; i < 5; i++) {
-    await boConvo.send({ text: `Message ${i}` })
-    await delayToPropogate()
-  }
-  if (allMessages.length <= 10) {
-    throw Error('Unexpected all messages count ' + allMessages.length)
-  }
-
-  return true
-})
-
 test('canManagePreferences', async () => {
   const bo = await Client.createRandom({ env: 'local' })
   const alix = await Client.createRandom({ env: 'local' })
diff --git a/example/yarn.lock b/example/yarn.lock
index aecbf6e14..94a1c57ee 100644
--- a/example/yarn.lock
+++ b/example/yarn.lock
@@ -13095,7 +13095,7 @@ prompts@^2.3.2, prompts@^2.4.0:
     kleur "^3.0.3"
     sisteransi "^1.0.5"
 
-prop-types@^15.6.2, prop-types@^15.7.2, prop-types@^15.8.0, prop-types@^15.8.1:
+prop-types@^15.5.10, prop-types@^15.6.2, prop-types@^15.7.2, prop-types@^15.8.0, prop-types@^15.8.1:
   version "15.8.1"
   resolved "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz"
   integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
@@ -13462,6 +13462,13 @@ react-native-mmkv@^2.8.0:
   resolved "https://registry.npmjs.org/react-native-mmkv/-/react-native-mmkv-2.11.0.tgz"
   integrity sha512-28PdUHjZJmAw3q+8zJDAAdohnZMpDC7WgRUJxACOMkcmJeqS3u5cKS/lSq2bhf1CvaeIiHYHUWiyatUjMRCDQQ==
 
+react-native-modal-selector@^2.1.2:
+  version "2.1.2"
+  resolved "https://registry.npmjs.org/react-native-modal-selector/-/react-native-modal-selector-2.1.2.tgz#c9fae030baf8bb2c5419e766ff63c31fc946f396"
+  integrity sha512-+Cvoz/yNUFmfIkJ7xkmlLR2nhJOUhx00S6BPqp2Ruy8LkmaiNr7WMZ4BzsgzylyEgZ84Q+42HQ0v0QzJYobviA==
+  dependencies:
+    prop-types "^15.5.10"
+
 react-native-modal@^13.0.1:
   version "13.0.1"
   resolved "https://registry.npmjs.org/react-native-modal/-/react-native-modal-13.0.1.tgz"