feat(insights): pyth metadata caching

apps/insights/next.config.js

@@ -3,7 +3,6 @@ const config = {
     useCache: true,
     reactCompiler: true,
   },
-
   reactStrictMode: true,
 
   pageExtensions: ["ts", "tsx", "mdx"],

apps/insights/package.json

@@ -28,10 +28,12 @@
     "@pythnetwork/known-publishers": "workspace:*",
     "@react-hookz/web": "catalog:",
     "@solana/web3.js": "catalog:",
+    "async-cache-dedupe": "catalog:",
     "bs58": "catalog:",
     "clsx": "catalog:",
     "cryptocurrency-icons": "catalog:",
     "dnum": "catalog:",
+    "ioredis": "^5.7.0",
     "lightweight-charts": "catalog:",
     "motion": "catalog:",
     "next": "catalog:",
@@ -44,7 +46,8 @@
     "superjson": "catalog:",
     "swr": "catalog:",
     "zod": "catalog:",
-    "zod-validation-error": "catalog:"
+    "zod-validation-error": "catalog:",
+    "zod-search-params": "catalog:"
   },
   "devDependencies": {
     "@cprussin/eslint-config": "catalog:",

apps/insights/src/app/api/pyth/get-feeds-for-publisher/[publisher]/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest } from "next/server";
+import { stringify } from "superjson";
+import { z } from "zod";
+import { parseSearchParams } from "zod-search-params";
+
+import {
+  Cluster,
+  CLUSTER_NAMES,
+  ClusterToName,
+  toCluster,
+} from "../../../../../services/pyth";
+import { getFeeds } from "../../../../../services/pyth/get-feeds";
+
+export const GET = async (
+  request: NextRequest,
+  { params }: { params: Promise<{ publisher: string }> },
+) => {
+  const { publisher } = await params;
+  const searchParams = request.nextUrl.searchParams;
+  const parsedSearchParams = parseSearchParams(queryParamsSchema, searchParams);
+
+  if (!parsedSearchParams) {
+    return new Response("Invalid params", {
+      status: 400,
+    });
+  }
+
+  const { cluster } = parsedSearchParams;
+
+  if (!publisher) {
+    return new Response("Publisher is required", {
+      status: 400,
+    });
+  }
+
+  const feeds = await getFeeds(cluster);
+
+  const filteredFeeds = feeds.filter((feed) =>
+    feed.price.priceComponents.some((c) => c.publisher === publisher),
+  );
+
+  return new Response(stringify(filteredFeeds), {
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+};
+
+const queryParamsSchema = z.object({
+  cluster: z
+    .enum(CLUSTER_NAMES)
+    .transform((value) => toCluster(value))
+    .default(ClusterToName[Cluster.Pythnet]),
+});

apps/insights/src/app/api/pyth/get-feeds/[symbol]/route.ts

@@ -0,0 +1,45 @@
+import { NextRequest } from "next/server";
+import { stringify } from "superjson";
+import { z } from "zod";
+import { parseSearchParams } from "zod-search-params";
+
+import {
+  Cluster,
+  CLUSTER_NAMES,
+  ClusterToName,
+  toCluster,
+} from "../../../../../services/pyth";
+import { getFeeds } from "../../../../../services/pyth/get-feeds";
+
+export const GET = async (
+  request: NextRequest,
+  { params }: { params: Promise<{ symbol: string }> },
+) => {
+  const { symbol } = await params;
+  const searchParams = request.nextUrl.searchParams;
+  const parsedSearchParams = parseSearchParams(queryParamsSchema, searchParams);
+
+  if (!parsedSearchParams) {
+    return new Response("Invalid params", {
+      status: 400,
+    });
+  }
+
+  const { cluster } = parsedSearchParams;
+
+  const feeds = await getFeeds(cluster);
+  const feed = feeds.find((feed) => feed.symbol === symbol);
+
+  return new Response(stringify(feed), {
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+};
+
+const queryParamsSchema = z.object({
+  cluster: z
+    .enum(CLUSTER_NAMES)
+    .transform((value) => toCluster(value))
+    .default(ClusterToName[Cluster.Pythnet]),
+});

apps/insights/src/app/api/pyth/get-feeds/route.ts

@@ -0,0 +1,41 @@
+import { NextRequest } from "next/server";
+import { stringify } from "superjson";
+import { z } from "zod";
+import { parseSearchParams } from "zod-search-params";
+
+import { CLUSTER_NAMES, toCluster } from "../../../../services/pyth";
+import { getFeeds } from "../../../../services/pyth/get-feeds";
+
+export const GET = async (request: NextRequest) => {
+  // get cluster from query params
+  const searchParams = request.nextUrl.searchParams;
+  const parsedSearchParams = parseSearchParams(queryParamsSchema, searchParams);
+
+  if (!parsedSearchParams) {
+    return new Response("Invalid params", {
+      status: 400,
+    });
+  }
+
+  const { excludePriceComponents, cluster } = parsedSearchParams;
+
+  const feeds = await getFeeds(cluster);
+  const filteredFeeds = excludePriceComponents
+    ? feeds.map((feed) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { price, ...rest } = feed;
+        return rest;
+      })
+    : feeds;
+
+  return new Response(stringify(filteredFeeds), {
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+};
+
+const queryParamsSchema = z.object({
+  cluster: z.enum(CLUSTER_NAMES).transform((value) => toCluster(value)),
+  excludePriceComponents: z.boolean(),
+});

apps/insights/src/app/api/pyth/get-publishers/[symbol]/route.ts

@@ -0,0 +1,45 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { parseSearchParams } from "zod-search-params";
+
+import {
+  Cluster,
+  CLUSTER_NAMES,
+  ClusterToName,
+  toCluster,
+} from "../../../../../services/pyth";
+import { getPublishersForCluster } from "../../../../../services/pyth/get-publishers-for-cluster";
+
+export const GET = async (
+  request: NextRequest,
+  { params }: { params: Promise<{ symbol: string }> },
+) => {
+  const { symbol } = await params;
+  const searchParams = request.nextUrl.searchParams;
+  const parsedSearchParams = parseSearchParams(queryParamsSchema, searchParams);
+
+  if (!parsedSearchParams) {
+    return new Response("Invalid params", {
+      status: 400,
+    });
+  }
+
+  const { cluster } = parsedSearchParams;
+
+  if (!symbol) {
+    return new Response("Symbol is required", {
+      status: 400,
+    });
+  }
+
+  const map = await getPublishersForCluster(cluster);
+
+  return NextResponse.json(map[symbol] ?? []);
+};
+
+const queryParamsSchema = z.object({
+  cluster: z
+    .enum(CLUSTER_NAMES)
+    .transform((value) => toCluster(value))
+    .default(ClusterToName[Cluster.Pythnet]),
+});

apps/insights/src/app/component-score-history/route.ts

@@ -16,13 +16,13 @@ export const GET = async (req: NextRequest) => {
   );
   if (parsed.success) {
     const { cluster, publisherKey, symbol, from, to } = parsed.data;
-    const data = await getFeedScoreHistory(
+    const data = await getFeedScoreHistory({
       cluster,
       publisherKey,
       symbol,
       from,
       to,
-    );
+    });
     return Response.json(data);
   } else {
     return new Response(fromError(parsed.error).toString(), {

apps/insights/src/app/historical-prices/route.ts

@@ -6,7 +6,10 @@ export async function GET(req: NextRequest) {
   const symbol = req.nextUrl.searchParams.get("symbol");
   const until = req.nextUrl.searchParams.get("until");
   if (symbol && until) {
-    const res = await getHistoricalPrices(decodeURIComponent(symbol), until);
+    const res = await getHistoricalPrices({
+      symbol: decodeURIComponent(symbol),
+      until,
+    });
     return Response.json(res);
   } else {
     return new Response("Must provide `symbol` and `until`", { status: 400 });

apps/insights/src/app/price-feeds/[slug]/layout.ts

@@ -2,7 +2,8 @@ import type { Metadata } from "next";
 import { notFound } from "next/navigation";
 import type { ReactNode } from "react";
 
-import { Cluster, getFeeds } from "../../../services/pyth";
+import { Cluster } from "../../../services/pyth";
+import { getFeeds } from "../../../services/pyth/get-feeds";
 
 export { PriceFeedLayout as default } from "../../../components/PriceFeed/layout";
 

apps/insights/src/components/Overview/index.tsx

@@ -9,7 +9,8 @@ import PriceFeedsLight from "./price-feeds-light.svg";
 import PublishersDark from "./publishers-dark.svg";
 import PublishersLight from "./publishers-light.svg";
 import { TabList } from "./tab-list";
-import { Cluster, getFeeds } from "../../services/pyth";
+import { Cluster } from "../../services/pyth";
+import { getFeeds } from "../../services/pyth/get-feeds";
 import {
   totalVolumeTraded,
   activeChains,
@@ -25,6 +26,7 @@ import { FormattedNumber } from "../FormattedNumber";
 export const Overview = async () => {
   const priceFeeds = await getFeeds(Cluster.Pythnet);
   const today = new Date();
+
   const feedCounts = [
     ...activeFeeds.map(({ date, numFeeds }) => ({
       x: date,
@@ -37,6 +39,7 @@ export const Overview = async () => {
       y: priceFeeds.length,
     },
   ];
+
   return (
     <div className={styles.overview}>
       <h1 className={styles.header}>Overview</h1>

apps/insights/src/components/PriceFeed/get-feed.tsx

@@ -1,20 +1,21 @@
 import { notFound } from "next/navigation";
 
-import { Cluster, getFeeds } from "../../services/pyth";
+import { getFeedForSymbolRequest, getFeedsRequest } from "../../server/pyth";
+import { Cluster } from "../../services/pyth";
 
 export const getFeed = async (params: Promise<{ slug: string }>) => {
-  "use cache";
+  const feeds = await getFeedsRequest(Cluster.Pythnet);
 
-  const [{ slug }, feeds] = await Promise.all([params, getPythnetFeeds()]);
+  const { slug } = await params;
   const symbol = decodeURIComponent(slug);
+  const feed = await getFeedForSymbolRequest({
+    symbol,
+    cluster: Cluster.Pythnet,
+  });
+
   return {
     feeds,
-    feed: feeds.find((item) => item.symbol === symbol) ?? notFound(),
+    feed: feed ?? notFound(),
     symbol,
   } as const;
 };
-
-const getPythnetFeeds = async () => {
-  "use cache";
-  return getFeeds(Cluster.Pythnet);
-};