feat: add v1 profiles (#7)

* feat: from & to as Avatar types

* feat: remove unused file

* feat: fetch v1 garden profiles

* feat: refactor load v1 garden profiles

* feat: cache.db with v1 profiles

* docs: update with from to updated

* feat: refactor to use string instead of avatar

DOCS.md

@@ -12,7 +12,8 @@ A unified view of all transfer transactions within the system, consolidating bot
   - `transactionHash`
   - `version`
   - `operator` (v2 only)
-  - `from`, `to`
+  - `from`
+  - `to`
   - `id`
   - `value`
   - `type` (transaction type; e.g., `Erc20WrapperTransfer`, `TransferSingle`, etc.)
@@ -26,16 +27,16 @@ It's possible to get demurrages that happened during transfers or mints.
 query getUserTransfers($address: String) {
 	Transfer(
     where:{
-      to:{_eq:$address},
-      transferType:{_neq:"Demurrage"}
+      to: {_eq:$address},
+      transferType: {_neq:"Demurrage"}
     }
-    order_by:{timestamp: desc}
+    order_by: {timestamp: desc}
   ) {
     id
-    from
+    from { id }
+    to { id }
     transferType
     timestamp
-    to
     value
     demurrageFrom {
       id
@@ -215,8 +216,10 @@ Defines the type of avatars.
   - `Invite`: v2 user that is not yet on circles and has at least one invite.
   - `RegisterGroup`: v2 group.
   - `RegisterOrganization`: v2 organization.
-  - `Unknown`: Placeholder during processing; unlikely to occur in steady state.
   - `Migrating`: v1 user that is migrating to v2.
+  - `Unknown`: Pending state.
+
+The `Unknown` pending state happens when a user created a v2 profile, but did not yet receive an invite or joined circles. Once the user receives de first invite, then the avatar type is `Invite`.
 
 Suppose you want to get the list of invited users by a given user.
 

src/cache.ts

@@ -5,8 +5,8 @@ import { Profile as Metadata } from "./types";
 const db = new sqlite3.Database(".cache/cache.db");
 
 export class ProfileCache {
-  static async init() {
-    const cache = new ProfileCache("cache_v2");
+  static async init(version: number) {
+    const cache = new ProfileCache("cache_cv" + version);
     await cache.createTableIfNotExists();
     return cache;
   }
@@ -37,7 +37,7 @@ export class ProfileCache {
     });
   }
 
-  public read(id: string): Promise<{ cidV0: string; data: Metadata } | null> {
+  public read(id: string): Promise<{ cidV0: string | null; data: Metadata } | null> {
     return new Promise((resolve, reject) => {
       const query = `SELECT data, cidV0 FROM ${this.key} WHERE id = ?`;
       db.get(query, [id], (err, row: any) => {
@@ -53,7 +53,7 @@ export class ProfileCache {
     });
   }
 
-  public async add(id: string, cidV0: string, metadata: Metadata) {
+  public async add(id: string, cidV0: string | null, metadata: Metadata) {
     const query = `INSERT INTO ${this.key} (id, cidV0, data) VALUES (?, ?, ?)`;
     const data = JSON.stringify(metadata);
 

src/event_handlers/hubV1.ts

@@ -3,6 +3,7 @@ import { maxUint256 } from "viem";
 import { incrementStats } from "../incrementStats";
 import { handleTransfer } from "../common/handleTransfer";
 import { defaultAvatarProps, makeAvatarBalanceEntityId } from "../utils";
+import { getProfileMetadataFromGardenApi } from "../gardenApi";
 
 // ###############
 // #### TOKEN ####
@@ -43,6 +44,22 @@ Hub.Signup.handlerWithLoader({
   handler: async ({ event, context, loaderReturn }) => {
     const { avatarBalance } = loaderReturn;
 
+    const profileFromGarden = await getProfileMetadataFromGardenApi(
+      event.params.user
+    );
+
+    if (profileFromGarden && profileFromGarden.data) {
+      const { data } = profileFromGarden;
+      context.Profile.set({
+        id: event.params.user,
+        description: undefined,
+        previewImageUrl: data?.previewImageUrl,
+        imageUrl: undefined,
+        name: data?.name,
+        symbol: undefined,
+      });
+    }
+
     context.Avatar.set({
       ...defaultAvatarProps(event),
       version: 1,
@@ -152,6 +169,10 @@ Hub.Trust.handlerWithLoader({
   handler: async ({ event, context, loaderReturn }) => {
     const { trustId, trustRelation, oppositeTrustRelation } = loaderReturn;
 
+    if (event.params.user === event.params.canSendTo) {
+      return;
+    }
+
     if (event.params.limit === 0n) {
       // this is untrust
       if (trustRelation && trustRelation.version === 1) {

src/event_handlers/hubV2.ts

@@ -209,14 +209,12 @@ HubV2.PersonalMint.handlerWithLoader({
 });
 
 NameRegistry.UpdateMetadataDigest.handler(async ({ event, context }) => {
-  let profileMetadata: { cidV0: string; data: Profile | null } | null = null;
+  let profileMetadata: { cidV0: string | null; data: Profile | null } | null = null;
   try {
     profileMetadata = await getProfileMetadataFromIpfs(
       event.params.metadataDigest
     );
-  } catch (_) {
-    console.log("Error in nameReg fetching Ipfs", _);
-  }
+  } catch (_) {}
 
   const avatar = await context.Avatar.get(event.params.avatar);
 
@@ -228,7 +226,7 @@ NameRegistry.UpdateMetadataDigest.handler(async ({ event, context }) => {
       id: event.params.avatar,
       avatarType: "Unknown",
       tokenId: bytesToBigInt(toBytes(event.params.avatar)).toString(),
-      cidV0: profileMetadata?.cidV0,
+      cidV0: profileMetadata?.cidV0 ?? undefined,
       profile_id: event.params.avatar,
     });
   } else {
@@ -239,7 +237,7 @@ NameRegistry.UpdateMetadataDigest.handler(async ({ event, context }) => {
     context.Avatar.set({
       ...avatar,
       avatarType: transitiveType,
-      cidV0: profileMetadata?.cidV0,
+      cidV0: profileMetadata?.cidV0 ?? undefined,
     });
   }
 

src/gardenApi.ts

@@ -0,0 +1,76 @@
+import { Profile } from "./types";
+import { ProfileCache } from "./cache";
+
+type GardenApiResponse = {
+  status: string;
+  data: {
+    id: number;
+    username: string;
+    avatarUrl: string | undefined;
+  }[];
+};
+type GardenProfile = {
+  name: string;
+  previewImageUrl: string | undefined;
+};
+/**
+ * This functions calls https://api.circles.garden/api/users?address[]=${address}
+ * which returns a GardenApiResponse object.
+ * GardenApiResponse contains an avatarUrl, which is also fetched and it's result is converted into a base 64 image.
+ * @param {string} address - The address of the user.
+ * @returns {Promise<{ data: GardenProfile | undefined; timeTaken: number }>} - The GardenProfile object and the time taken to fetch it.
+ */
+async function fetchGardenProfile(
+  address: string
+): Promise<{ data: GardenProfile | undefined; timeTaken: number }> {
+  const startTime = Date.now();
+
+  try {
+    const response = await fetch(
+      `https://api.circles.garden/api/users?address[]=${address}`
+    );
+    const json = (await response.json()) as GardenApiResponse;
+
+    if (json.status !== "ok" || json.data.length === 0) {
+      return { data: undefined, timeTaken: Date.now() - startTime };
+    }
+
+    const user = json.data[0];
+
+    return {
+      data: {
+        name: user.username,
+        previewImageUrl: user.avatarUrl,
+      },
+      timeTaken: Date.now() - startTime,
+    };
+  } catch (error) {
+    console.error("Error fetching garden profile:", error);
+    return { data: undefined, timeTaken: Date.now() - startTime };
+  }
+}
+
+export async function getProfileMetadataFromGardenApi(
+  address: string
+): Promise<{ data: Profile | null } | null> {
+  if (!address) {
+    return null;
+  }
+
+  const cache = await ProfileCache.init(1);
+  const cacheResult = await cache.read(address);
+
+  if (cacheResult) {
+    return { data: cacheResult.data };
+  }
+
+  const { data } = await fetchGardenProfile(address);
+  if (!data) {
+    return null;
+  }
+
+  // v1 did not had cidV0
+  await cache.add(address, null, data);
+
+  return { data };
+}

src/ipfs.ts

@@ -1,7 +1,5 @@
-import multihash from "multihashes";
 import { Profile } from "./types";
-/* import { ProfileCache } from "./cache";
- */ import { Avatar, eventLog } from "generated";
+import { ProfileCache } from "./cache";
 import { uint8ArrayToCidV0 } from "./utils";
 
 // Simple config with only needed values
@@ -74,30 +72,28 @@ async function fetchFromEndpoint(
 
 export async function getProfileMetadataFromIpfs(
   metadataDigest: string
-): Promise<{ cidV0: string; data: Profile | null } | null> {
+): Promise<{ cidV0: string | null; data: Profile | null } | null> {
   if (!metadataDigest) {
     return null;
   }
   const slicedDigest = metadataDigest.slice(2, metadataDigest.length);
 
-  /*   const cache = await ProfileCache.init();
+  const cache = await ProfileCache.init(2);
   const cacheResult = await cache.read(slicedDigest);
 
   if (cacheResult) {
     return cacheResult;
-  } */
+  }
 
   const cidV0 = uint8ArrayToCidV0(
     Uint8Array.from(Buffer.from(slicedDigest, "hex"))
   );
 
   // Try each endpoint until we get a successful response
   for (const endpoint of IPFS_ENDPOINTS) {
-    const { data, timeTaken } = await fetchFromEndpoint(endpoint, cidV0);
-    console.log(`IPFS fetch from ${endpoint} took ${timeTaken.toFixed(2)}ms`);
+    const { data } = await fetchFromEndpoint(endpoint, cidV0);
     if (data) {
-      console.log("Adding IPFS data to cache", data);
-      //await cache.add(slicedDigest, cidV0, data);
+      await cache.add(slicedDigest, cidV0, data);
       return { cidV0, data };
     }
   }

src/utils.ts

@@ -1,5 +1,4 @@
 import multihash from "multihashes";
-import { Profile } from "./types";
 import { Avatar, eventLog } from "generated";
 
 /**