checkpoint

Author: technoplato

features/conversation-list/hooks/use-conversations-count.ts

@@ -1,5 +1,7 @@
 import { generateGroupHashFromMemberIds } from "@/features/create-conversation/generate-group-hash-from-member-ids";
 import { getConversationsQueryOptions } from "@/queries/use-conversations-query";
+import { getGroupMembersQueryData } from "@/queries/useGroupMembersQuery";
+import { getCleanAddress } from "@/utils/evm/getCleanAddress";
 import logger from "@/utils/logger";
 import {
   getCurrentAccount,
@@ -22,58 +24,77 @@ export const useConversationsCount = () => {
   return { count, isLoading };
 };
 
-export const useFindConversationByMembers = (members: InboxId[]) => {
+export const useFindConversationByMembers = (membersToSearch: InboxId[]) => {
   const account = useCurrentAccount();
 
   logger.debug(
     `[useFindConversationByMembers] Finding conversation for members:`,
-    members
+    membersToSearch
   );
 
-  const membersHash = generateGroupHashFromMemberIds([
-    ...members,
-    getCurrentAccount()!,
-  ]);
-
-  logger.debug(
-    `[useFindConversationByMembers] Generated members hash: ${membersHash}`
-  );
-
-  const { data: conversation, isLoading } = useQuery({
+  const { data: conversations, isLoading } = useQuery({
     ...getConversationsQueryOptions({
       account: account!,
       caller: "useConversationByMembers",
     }),
-    select: (data) => {
+    select: (conversations) => {
       logger.debug(
-        `[useFindConversationByMembers] Searching through ${data?.length} conversations`
+        `[useFindConversationByMembers] Searching through ${conversations?.length} conversations`
       );
 
-      const found = data?.find((c) => {
-        const matches = c.membersHash === membersHash;
+      const groupsThatIncludeMembers = conversations?.filter((c) => {
+        logger.debug(
+          `[useFindConversationByMembers] Checking conversation ${c.topic}`
+        );
+
+        const groupMembers = getGroupMembersQueryData(account!, c.topic);
         logger.debug(
-          `[useFindConversationByMembers] Checking conversation ${c.topic}:`,
-          `membersHash=${c.membersHash}`,
-          `matches=${matches}`
+          `[useFindConversationByMembers] Group members for ${c.topic}:`,
+          groupMembers?.ids
+        );
+
+        const membersIdsSet = new Set(
+          groupMembers?.addresses.map((address) => address.toLowerCase()) ?? []
+        );
+        const membersToSearchSet = new Set(
+          membersToSearch.map((member) => member.toLowerCase())
         );
-        return matches;
+
+        logger.debug(
+          `[useFindConversationByMembers] Checking if\n${Array.from(
+            membersToSearchSet
+          )}\n is subset of\n${Array.from(membersIdsSet).join("\n")}`
+        );
+
+        // const areMembersToSearchAllInGroup =
+        //   membersToSearchSet.isSubsetOf(membersIdsSet);
+        // write brute force subset check
+        const areMembersToSearchAllInGroup = membersToSearch.every((member) =>
+          membersIdsSet.has(member.toLowerCase())
+        );
+
+        logger.debug(
+          `[useFindConversationByMembers] Members are ${
+            areMembersToSearchAllInGroup ? "" : "not "
+          }all in group ${c.topic}`
+        );
+
+        return areMembersToSearchAllInGroup;
       });
 
       logger.debug(
-        `[useFindConversationByMembers] Found conversation:`,
-        found ? found.topic : "none"
+        `[useFindConversationByMembers] Found ${groupsThatIncludeMembers?.length} conversations that include members`
       );
 
-      return found;
+      return groupsThatIncludeMembers;
     },
-    enabled: !!membersHash,
+    enabled: !!membersToSearch && membersToSearch.length > 0,
   });
 
   logger.debug(
     `[useFindConversationByMembers] Returning:`,
-    `conversation=${conversation?.topic ?? "nope!"}`,
     `isLoading=${isLoading}`
   );
 
-  return { conversation, isLoading };
+  return { conversations, isLoading };
 };

features/create-conversation/create-conversation-screen.tsx

@@ -46,10 +46,10 @@ export function CreateConversationScreen({
     }>
   >([]);
   const {
-    conversation: existingConversation,
+    conversations: existingConversations,
     isLoading: isLoadingExistingConversation,
   } = useFindConversationByMembers(selectedUsers.map((u) => u.address));
-  logJson({ json: existingConversation, msg: "existingConversation" });
+  logJson({ json: existingConversations, msg: "existingConversations" });
 
   const selectedUsersCount = selectedUsers.length;
   const composerDisabled = selectedUsersCount === 0;
@@ -205,14 +205,18 @@ export function CreateConversationScreen({
         </View>
       )}
 
-      {existingConversation && (
+      {existingConversations && (
         <MessageSection
-          message={`Conversation already exists with ${existingConversation.topic}`}
+          message={`${
+            existingConversations.length
+          } conversations already exist with ${selectedUsers
+            .map((u) => u.name)
+            .join(", ")}`}
           isError={false}
         />
       )}
 
-      {!existingConversation && !isLoadingExistingConversation && (
+      {!existingConversations && !isLoadingExistingConversation && (
         <MessageSection
           message={"Conversation does not exist with those members"}
           isError={false}

queries/entify.ts

@@ -56,6 +56,7 @@ export type EntityObjectWithAddress<T, KeyType extends string = string> = {
   byId: Record<KeyType, T>;
   byAddress: Record<string, KeyType>;
   ids: KeyType[];
+  addresses: string[];
 };
 
 /**
@@ -99,6 +100,7 @@ export function entifyWithAddress<T, KeyType extends string = string>(
       const id = idFunc(item);
       const address = addressFunc(item);
       acc.ids.push(id);
+      acc.addresses.push(address);
       acc.byId[id] = item;
       acc.byAddress[address] = id;
       return acc;
@@ -107,6 +109,7 @@ export function entifyWithAddress<T, KeyType extends string = string>(
       byId: {} as Record<KeyType, T>,
       byAddress: {},
       ids: [],
+      addresses: [],
     }
   );
 }

queries/useGroupMembersQuery.ts

@@ -8,6 +8,7 @@ import { entifyWithAddress, EntityObjectWithAddress } from "./entify";
 import { queryClient } from "./queryClient";
 import { groupMembersQueryKey } from "./QueryKeys";
 import { getOrFetchGroupQuery } from "./useGroupQuery";
+import logger from "@utils/logger";
 
 export type GroupMembersSelectData = EntityObjectWithAddress<Member, InboxId>;
 
@@ -16,6 +17,11 @@ const fetchGroupMembers = async (args: {
   topic: ConversationTopic;
 }): Promise<EntityObjectWithAddress<Member, InboxId>> => {
   const { account, topic } = args;
+  logger.debug("[fetchGroupMembers] Fetching group members", {
+    account,
+    topic,
+  });
+
   const group = await getOrFetchGroupQuery({
     account,
     topic,
@@ -28,6 +34,11 @@ const fetchGroupMembers = async (args: {
 
   const members = await group.members();
 
+  logger.debug("[fetchGroupMembers] Successfully fetched members", {
+    topic,
+    memberCount: members.length,
+  });
+
   return entifyWithAddress(
     members,
     (member) => member.inboxId,
@@ -116,10 +127,10 @@ export async function ensureGroupMembersQueryData(args: {
   topic: ConversationTopic;
 }) {
   const { account, topic } = args;
-  return queryClient.ensureQueryData({
-    queryKey: getGroupMemberQueryOptions({
+  return queryClient.ensureQueryData(
+    getGroupMemberQueryOptions({
       account,
       topic,
-    }).queryKey,
-  });
+    })
+  );
 }

queries/useGroupQuery.ts

@@ -70,15 +70,6 @@ export function getGroupQueryOptions(args: {
       if (!data) {
         return null;
       }
-      /**
-       * Type error: Group<SupportedCodecsType> | Dm<SupportedCodecsType> is not
-       * assignable to ConversationWithCodecsType. Group<SupportedCodecsType> is
-       * missing resolvedMembers and membersHash properties.
-       *
-       * note(lustig) I really think we should get away from leaking xmtp types into our codebase.
-       * these generics are starting to be very annoying and counter productive.
-       */
-      // @ts-expect-error TS2345
       if (!isConversationGroup(data)) {
         throw new Error(
           "Expected group conversation but received different type"

utils/xmtpRN/client.types.ts

@@ -30,12 +30,7 @@ export type SupportedCodecsType = [
 
 export type ConverseXmtpClientType = Client<SupportedCodecsType>;
 
-// export type ConversationWithCodecsType = Conversation<SupportedCodecsType>;
-
-export type ConversationWithCodecsType = Conversation<SupportedCodecsType> & {
-  resolvedMembers: Member[];
-  membersHash: string;
-};
+export type ConversationWithCodecsType = Conversation<SupportedCodecsType>;
 
 export type DmWithCodecsType = Dm<SupportedCodecsType>;