Refactor governance proposal metadata handling

- Moved metadata fetching and normalization logic to a dedicated module.
- Introduced `fetchProposalMetadataWithFallback` to streamline metadata retrieval with fallback options.
- Simplified proposal metadata normalization and fallback creation.
- Added tests for proposal metadata helpers to ensure functionality and reliability.
- Removed redundant code and improved overall code organization for better maintainability.

Author: Andre-Diamond

src/__tests__/proposalMetadata.test.ts

@@ -0,0 +1,163 @@
+import { afterEach, describe, expect, it, jest } from "@jest/globals";
+import {
+  createProposalMetadataFallback,
+  fetchProposalMetadataWithFallback,
+  getAnchorUrls,
+  normalizeProposalMetadata,
+} from "@/lib/governance/proposalMetadata";
+
+const proposal = {
+  tx_hash: "tx-proposal",
+  cert_index: 0,
+  governance_type: "info_action",
+};
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("proposal metadata helpers", () => {
+  it("normalizes usable Blockfrost metadata without extra fetching", async () => {
+    const provider = {
+      get: jest.fn(async () => ({
+        tx_hash: "tx-proposal",
+        cert_index: 0,
+        hash: "hash",
+        url: "https://example.com/metadata.json",
+        bytes: "123",
+        json_metadata: {
+          body: {
+            title: "Proposal title",
+            abstract: "Proposal abstract",
+            motivation: "Motivation",
+            rationale: "Rationale",
+            references: [{ "@type": "Other", label: "Spec", uri: "https://example.com" }],
+          },
+          authors: [{ name: "Ada" }],
+        },
+      })),
+    };
+
+    const metadata = await fetchProposalMetadataWithFallback({ provider, proposal });
+
+    expect(provider.get).toHaveBeenCalledTimes(1);
+    expect(metadata).toMatchObject({
+      tx_hash: "tx-proposal",
+      cert_index: 0,
+      governance_type: "info_action",
+      hash: "hash",
+      json_metadata: {
+        body: {
+          title: "Proposal title",
+          abstract: "Proposal abstract",
+          motivation: "Motivation",
+          rationale: "Rationale",
+        },
+        authors: [{ name: "Ada" }],
+      },
+    });
+  });
+
+  it("hydrates metadata from a regular anchor URL", async () => {
+    const provider = {
+      get: jest.fn(async () => ({
+        tx_hash: "tx-proposal",
+        cert_index: 0,
+        url: "https://example.com/anchor.json",
+      })),
+    };
+    const fetchSpy = jest.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          body: {
+            title: "Anchor title",
+            abstract: "Anchor abstract",
+          },
+          authors: [{ name: "Anchor author" }],
+        }),
+        { status: 200 },
+      ),
+    );
+
+    const metadata = await fetchProposalMetadataWithFallback({ provider, proposal });
+
+    expect(fetchSpy).toHaveBeenCalledWith(
+      "https://example.com/anchor.json",
+      expect.objectContaining({ method: "GET" }),
+    );
+    expect(metadata?.json_metadata.body.title).toBe("Anchor title");
+    expect(metadata?.json_metadata.authors).toEqual([{ name: "Anchor author" }]);
+  });
+
+  it("tries IPFS gateway fallbacks until one returns usable JSON", async () => {
+    expect(getAnchorUrls("ipfs://cid/path.json")).toEqual([
+      "https://ipfs.io/ipfs/cid/path.json",
+      "https://cloudflare-ipfs.com/ipfs/cid/path.json",
+      "https://dweb.link/ipfs/cid/path.json",
+    ]);
+
+    const provider = {
+      get: jest.fn(async () => ({
+        tx_hash: "tx-proposal",
+        cert_index: 0,
+        url: "ipfs://cid/path.json",
+      })),
+    };
+    const fetchSpy = jest
+      .spyOn(globalThis, "fetch")
+      .mockResolvedValueOnce(new Response("not found", { status: 504 }))
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ title: "Wrapped anchor title" }), {
+          status: 200,
+        }),
+      );
+
+    const metadata = await fetchProposalMetadataWithFallback({ provider, proposal });
+
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+    expect(metadata?.json_metadata.body.title).toBe("Wrapped anchor title");
+  });
+
+  it("returns fallback metadata without changing the ProposalMetadata shape", () => {
+    const metadata = createProposalMetadataFallback(proposal);
+
+    expect(metadata).toEqual({
+      tx_hash: "tx-proposal",
+      cert_index: 0,
+      governance_type: "info_action",
+      hash: "",
+      url: "",
+      bytes: "",
+      json_metadata: {
+        body: {
+          title: "Metadata could not be loaded.",
+          abstract: "tx-proposal#0",
+          motivation: "",
+          rationale: "",
+          references: [],
+        },
+        authors: [],
+      },
+    });
+  });
+
+  it("normalizes missing or unusable metadata fields into safe defaults", () => {
+    const metadata = normalizeProposalMetadata({ json_metadata: { body: null } }, proposal);
+
+    expect(metadata).toMatchObject({
+      tx_hash: "tx-proposal",
+      cert_index: 0,
+      governance_type: "info_action",
+      json_metadata: {
+        body: {
+          title: "Metadata could not be loaded.",
+          abstract: "tx-proposal#0",
+          motivation: "",
+          rationale: "",
+          references: [],
+        },
+        authors: [],
+      },
+    });
+  });
+});

src/components/pages/wallet/governance/proposal/index.tsx

@@ -17,131 +17,10 @@ import ReactMarkdown from 'react-markdown';
 import remarkGfm from "remark-gfm";
 import { Badge } from "@/components/ui/badge";
 import { CheckCircle2, XCircle, Clock, Calendar, Coins, Hash, FileText, Wallet } from "lucide-react";
-
-const hasUsableJsonMetadata = (value: any): boolean =>
-  Boolean(value && typeof value === "object" && value.body && typeof value.body === "object");
-
-const getAnchorUrls = (anchorUrl: string): string[] => {
-  if (!anchorUrl) return [];
-  if (!anchorUrl.startsWith("ipfs://")) {
-    return [anchorUrl];
-  }
-  const cidPath = anchorUrl.replace("ipfs://", "");
-  return [
-    `https://ipfs.io/ipfs/${cidPath}`,
-    `https://cloudflare-ipfs.com/ipfs/${cidPath}`,
-    `https://dweb.link/ipfs/${cidPath}`,
-  ];
-};
-
-async function fetchJsonFromUrl(url: string): Promise<any> {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 10000);
-  try {
-    const res = await fetch(url, {
-      method: "GET",
-      headers: { Accept: "application/json" },
-      signal: controller.signal,
-    });
-    if (!res.ok) {
-      throw new Error(`HTTP ${res.status} ${res.statusText}`);
-    }
-    const text = await res.text();
-    return JSON.parse(text);
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-async function hydrateMetadataFromAnchor(rawMetadata: any, txHash: string, certIndex: number): Promise<any> {
-  if (hasUsableJsonMetadata(rawMetadata?.json_metadata)) {
-    return rawMetadata;
-  }
-  const anchorUrl =
-    typeof rawMetadata?.url === "string" && rawMetadata.url.length > 0
-      ? rawMetadata.url
-      : null;
-  if (!anchorUrl) return rawMetadata;
-
-  const candidateUrls = getAnchorUrls(anchorUrl);
-  for (const url of candidateUrls) {
-    try {
-      const anchorJson = await fetchJsonFromUrl(url);
-      const jsonMetadata = anchorJson?.body ? anchorJson : { body: anchorJson };
-      if (hasUsableJsonMetadata(jsonMetadata)) {
-        return { ...rawMetadata, json_metadata: jsonMetadata };
-      }
-    } catch {
-      // Try next URL candidate.
-    }
-  }
-  return rawMetadata;
-}
-
-const normalizeProposalMetadata = (
-  rawMetadata: any,
-  txHash: string,
-  certIndex: number,
-): ProposalMetadata => {
-  const rawBody = rawMetadata?.json_metadata?.body;
-  const body = rawBody && typeof rawBody === "object" ? rawBody : {};
-  const rawAuthors = rawMetadata?.json_metadata?.authors;
-  const authors = Array.isArray(rawAuthors)
-    ? rawAuthors
-        .map((author) =>
-          typeof author?.name === "string" ? { name: author.name } : null,
-        )
-        .filter((author): author is { name: string } => Boolean(author))
-    : [];
-  const references = Array.isArray((body as any).references)
-    ? (body as any).references.filter(
-        (ref: any) =>
-          ref &&
-          typeof ref === "object" &&
-          typeof ref.label === "string" &&
-          typeof ref.uri === "string" &&
-          typeof ref["@type"] === "string",
-      )
-    : [];
-
-  return {
-    tx_hash:
-      typeof rawMetadata?.tx_hash === "string" ? rawMetadata.tx_hash : txHash,
-    cert_index:
-      Number.isFinite(Number(rawMetadata?.cert_index))
-        ? Number(rawMetadata.cert_index)
-        : certIndex,
-    governance_type:
-      typeof rawMetadata?.governance_type === "string"
-        ? rawMetadata.governance_type
-        : "",
-    hash: typeof rawMetadata?.hash === "string" ? rawMetadata.hash : "",
-    url: typeof rawMetadata?.url === "string" ? rawMetadata.url : "",
-    bytes: typeof rawMetadata?.bytes === "string" ? rawMetadata.bytes : "",
-    json_metadata: {
-      body: {
-        title:
-          typeof (body as any).title === "string"
-            ? (body as any).title
-            : "Metadata could not be loaded.",
-        abstract:
-          typeof (body as any).abstract === "string"
-            ? (body as any).abstract
-            : `${txHash}#${certIndex}`,
-        motivation:
-          typeof (body as any).motivation === "string"
-            ? (body as any).motivation
-            : "",
-        rationale:
-          typeof (body as any).rationale === "string"
-            ? (body as any).rationale
-            : "",
-        references,
-      },
-      authors,
-    },
-  };
-};
+import {
+  createProposalMetadataFallback,
+  fetchProposalMetadataWithFallback,
+} from "@/lib/governance/proposalMetadata";
 
 function WalletGovernanceProposalContent({ id }: { id: string }) {
   const network = useSiteStore((state) => state.network);
@@ -186,40 +65,19 @@ function WalletGovernanceProposalContent({ id }: { id: string }) {
           .get(detailsPath)
           .catch(() => null) as Promise<ProposalDetails | null>;
 
-        // Try primary metadata path first.
-        let metadata: ProposalMetadata | null = null;
-        const metadataPath = `/governance/proposals/${txHash}/${certIndex}/metadata`;
-        try {
-          metadata = (await hydrateMetadataFromAnchor(
-            await blockchainProvider.get(metadataPath),
-            txHash,
-            Number(certIndex),
-          )) as ProposalMetadata;
-        } catch {
-
-          // Fallback: use details.id (gov_action_id) endpoint when available.
-          const detailsForFallback = await detailsPromise;
-          const govActionId =
-            detailsForFallback && typeof detailsForFallback.id === "string"
-              ? detailsForFallback.id
-              : null;
-
-          if (govActionId) {
-            const fallbackPath = `/governance/proposals/${govActionId}/metadata`;
-            try {
-              metadata = (await hydrateMetadataFromAnchor(
-                await blockchainProvider.get(fallbackPath),
-                txHash,
-                Number(certIndex),
-              )) as ProposalMetadata;
-            } catch {
-              // Use default metadata below.
-            }
-          }
-        }
+        const proposal = {
+          tx_hash: txHash,
+          cert_index: Number(certIndex),
+          governance_type: "",
+        };
+        const metadata = await fetchProposalMetadataWithFallback({
+          provider: blockchainProvider,
+          proposal,
+          fetchDetails: () => detailsPromise,
+        });
 
         setProposalMetadata(
-          normalizeProposalMetadata(metadata, txHash, Number(certIndex)),
+          metadata ?? createProposalMetadataFallback(proposal),
         );
 
         // Fetch proposal details