chore: new release

allowlists/getAllowListRecordsForAddressByClaimed.tsx → allowlists/actions/getAllowListRecordsForAddressByClaimed.tsx

@@ -38,22 +38,17 @@ const query = graphql(
   [AllowListRecordFragment],
 );
 
-export async function getAllowListRecordsForAddressByClaimed(
-  address: string,
-  claimed: boolean,
-) {
-  const res = await request(
-    HYPERCERTS_API_URL_GRAPH,
-    query,
-    {
-      address,
-      claimed,
-    },
-    new Headers({
-      "Cache-Control": "no-cache",
-      Pragma: "no-cache",
-    }),
-  );
+export async function getAllowListRecordsForAddressByClaimed({
+  address,
+  claimed,
+}: {
+  address: string;
+  claimed: boolean;
+}) {
+  const res = await request(HYPERCERTS_API_URL_GRAPH, query, {
+    address,
+    claimed,
+  });
 
   const allowlistRecords = res.allowlistRecords.data;
   if (!allowlistRecords) {

allowlists/actions/getAllowListRecordsForAddressByClaimedWithMetadata.tsx

@@ -0,0 +1,101 @@
+import "server-only";
+
+import { ResultOf, graphql, readFragment } from "@/lib/graphql";
+
+import request from "graphql-request";
+import { HYPERCERTS_API_URL_GRAPH } from "@/configs/hypercerts";
+import { getHypercertMetadata } from "@/hypercerts/actions/getHypercertMetadata";
+import { UnclaimedFraction } from "@/components/profile/unclaimed-hypercerts-list";
+
+export const AllowListRecordFragment = graphql(`
+  fragment AllowListRecordFragment on AllowlistRecord {
+    id
+    hypercert_id
+    token_id
+    root
+    leaf
+    entry
+    user_address
+    claimed
+    proof
+    units
+    total_units
+  }
+`);
+export type AllowListRecord = ResultOf<typeof AllowListRecordFragment>;
+
+const query = graphql(
+  `
+    query allowlistRecords($address: String, $claimed: Boolean) {
+      allowlistRecords(
+        where: { user_address: { eq: $address }, claimed: { eq: $claimed } }
+      ) {
+        count
+        data {
+          ...AllowListRecordFragment
+        }
+      }
+    }
+  `,
+  [AllowListRecordFragment],
+);
+
+const requestMap = new Map<string, Promise<any>>();
+
+async function getMetadataWithDeduping(hypercertId: string) {
+  if (requestMap.has(hypercertId)) {
+    return requestMap.get(hypercertId);
+  }
+
+  const requestPromise = getHypercertMetadata(hypercertId);
+  requestMap.set(hypercertId, requestPromise);
+
+  return await requestPromise;
+}
+
+export async function getAllowListRecordsForAddressByClaimedWithMetadata({
+  address,
+  claimed,
+}: {
+  address: string;
+  claimed: boolean;
+}): Promise<
+  { data: UnclaimedFraction[] | null; count: number | null } | undefined
+> {
+  const res = await request(HYPERCERTS_API_URL_GRAPH, query, {
+    address,
+    claimed,
+  });
+
+  const allowlistRecords = res.allowlistRecords.data;
+  if (!allowlistRecords) {
+    return undefined;
+  }
+  const allowlistRecordsRead = readFragment(
+    AllowListRecordFragment,
+    allowlistRecords,
+  );
+
+  const count = res.allowlistRecords.count;
+
+  if (allowlistRecordsRead && allowlistRecordsRead.length > 0) {
+    const processedData = await Promise.all(
+      allowlistRecordsRead.map(async (fraction) => {
+        const metadata = fraction.hypercert_id
+          ? await getMetadataWithDeduping(fraction.hypercert_id)
+          : null;
+        return { ...fraction, metadata: metadata?.data ?? null };
+      }),
+    );
+
+    return {
+      count,
+      data: processedData,
+    };
+  }
+
+  return {
+    count,
+    data: [...allowlistRecordsRead],
+  };
+}

app/actions/revalidatePathServerAction.ts

@@ -9,11 +9,12 @@ export async function revalidatePathServerAction(
 ) {
   const pathArray = Array.isArray(paths) ? paths : [paths];
 
-  pathArray.forEach((p) => {
+  for (const p of pathArray) {
+    console.debug("Revalidating path: ", p);
     if (typeof p === "string") {
       revalidatePath(p);
     } else {
       revalidatePath(p.path, p.type);
     }
-  });
+  }
 }

app/api/hypercerts/[hypercertId]/metadata/route.ts

@@ -0,0 +1,26 @@
+import { getHypercertMetadata } from "@/hypercerts/actions/getHypercertMetadata";
+import { NextResponse } from "next/server";
+
+export async function GET(
+  request: Request,
+  { params }: { params: { hypercertId: string } },
+) {
+  try {
+    const data = await getHypercertMetadata(params.hypercertId);
+
+    if (!data) {
+      return NextResponse.json(
+        { error: "Metadata not found" },
+        { status: 404 },
+      );
+    }
+
+    return NextResponse.json(data);
+  } catch (error) {
+    console.error("Error fetching hypercert metadata:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch metadata" },
+      { status: 500 },
+    );
+  }
+}

app/hypercerts/[hypercertId]/page.tsx

@@ -1,6 +1,6 @@
 import { Metadata, ResolvingMetadata } from "next";
 
-import { getHypercert } from "@/hypercerts/getHypercert";
+import { getHypercert } from "@/hypercerts/actions/getHypercert";
 
 import CreatorFeedButton from "@/components/creator-feed/creator-feed-button";
 import CreatorFeeds from "@/components/creator-feed/creator-feeds";

app/profile/[address]/page.tsx

@@ -4,7 +4,7 @@ import {
 } from "@/app/profile/[address]/tabs";
 
 import EthAddress from "@/components/eth-address";
-import { HypercertsTabContent } from "@/app/profile/[address]/hypercerts-tab-content";
+import { HypercertsTabContent } from "@/components/profile/hypercerts-tab/hypercerts-tab-content";
 import { CollectionsTabContent } from "@/app/profile/[address]/collections-tab-content";
 import { MarketplaceTabContent } from "@/app/profile/[address]/marketplace-tab-content";
 import { BlueprintsTabContent } from "@/app/profile/[address]/blueprint-tab-content";

components/allowlist/create-allowlist-dialog.tsx

@@ -1,6 +1,5 @@
 "use client";
 
-import { ChangeEvent, useEffect, useState } from "react";
 import {
   Dialog,
   DialogContent,
@@ -9,17 +8,18 @@ import {
   DialogTitle,
 } from "@/components/ui/dialog";
 import { LoaderCircle, MinusCircle, PlusCircle } from "lucide-react";
+import { ChangeEvent, useEffect, useState } from "react";
 import { isAddress } from "viem";
 
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
-import { cn } from "@/lib/utils";
-import { errorHasMessage } from "@/lib/errorHasMessage";
 import { toast } from "@/components/ui/use-toast";
-import { useValidateAllowlist } from "@/hypercerts/hooks/useCreateAllowLists";
+import { errorHasMessage } from "@/lib/errorHasMessage";
+import { cn } from "@/lib/utils";
 import { AllowlistEntry } from "@hypercerts-org/sdk";
 
 import { DEFAULT_NUM_UNITS } from "@/configs/hypercerts";
+import { useValidateAllowList } from "@/hypercerts/hooks/useValidateAllowList";
 
 type AllowListItem = {
   address?: string;
@@ -54,7 +54,7 @@ export default function Component({
     isPending,
     error: createAllowListError,
     reset,
-  } = useValidateAllowlist();
+  } = useValidateAllowList();
   const [allowList, setAllowList] = useState<AllowListItem[]>(
     initialValues?.length ? initialValues : defaultValues,
   );

components/evaluations/evaluation-list-item/hypercert-row.tsx

@@ -1,5 +1,5 @@
 import Image from "next/image";
-import { getHypercert } from "@/hypercerts/getHypercert";
+import { getHypercert } from "@/hypercerts/actions/getHypercert";
 
 export default async function HypercertRow({
   hypercertId,